Programacin Orientada a Objetos

Historia de la programacin
Inicios
Lenguaje de mquina : Unos y Ceros

1940
Lenguaje Ensamblador : Mnemonicos

1950
Lenguajes de Alto nivel : Basic, Cobol, Fortran, etc
Sentencias GOTO Cantidad de lneas 20.000

1970
Programacin Estructurada : Pascal, C, etc
Bifurcacin y control (while/for/switch/etc..) Cantidad mxima de lneas 50.000

1970
Programacin Orientada a Objetos : SmallTalk, C++, ObjectiveC, Java, Delphi, etc
Agrupa datos y cdigo : Encapsulamiento y Abstraccin. Mayor complejidad

Historia de la programacin

Algunas diferencias entre C y C++

Comentarios
int main() { // this is end-of-line comment // one comment per line /* this is standard-C comment, over more than one line */ return (0); }

Definicin de variables fuera de orden

#include <stdio.h> int main() { for (register int i = 0; i < 20; i++) printf("%d\n", i); return (0); }

Sobrecarga de funciones
#include <stdio.h> void show(int val) { printf("Integer: %d\n", val); } void show(double val) { printf("Double: %lf\n", val); } void show(char *val) { printf("String: %s\n", val); } int main() { show(12); show(3.1415); show("Hello World\n!"); return (0); }

Funciones como partes de un struct

struct point { int x, y; void draw(void); }; // definition of a screen // dot: // coordinates // x/y // drawing function

Ejemplo de uso de la estructura point

point a, b; a.x = 0; a.y = 10; a.draw(); b = a; b.y = 20; b.draw(); // two points on // screen

// define first dot // and draw it

// copy a to b // redefine y-coord // and draw it

Entrada / Salida en C++

cout, anlogo a stdout cin, anlogo a stdin cerr, anlogo a stderr #include <iostream> void main() { int ival; char sval[30]; cout << "Enter a number:" << endl; cin >> ival; cout << "And now a string:" << endl; cin >> sval; cout << "The number is: " << ival << endl << "And the string is: " << sval << endl; }

Entrada / Salida en C++

Ejemplo:
#include <iostream.h> int main() { int i = 123; for(int j=0;j<25;j++) { cout << endl; } cout << "Hello there.\n"; cout << "Here is 5: " << 5 << "\n"; cout << "The manipulator endl writes a new line to the screen." << endl; cout << "Here is a very big number:\t" << 70000 << endl; cout << "Here is the sum of 8 and 5:\t" << 8+5 << endl; cout << "Here's a fraction:\t\t" << (float) 5/8 << endl; cout << "And a very very big number:\t" << (double) 7000 * 7000 << endl; cout << "And finally an integer variable:\t" << i << endl; cout << "Now let's modify i, give a number: "; cin >> i; cout << "The integer variable now have's the number: " << i << endl; return 0; }

Declaracin fuera de lugar

Introduccin a objetos

Introduccin Objetos
definir clase Perro: propiedad sexo en {macho, hembra} propiedad color en {blanco, marrn, negro, mixto} propiedad cansancio en (nada, poco, moderado, mucho, exhausto) ... otras propiedades ... mtodo paseo() devuelve cansancio mtodo quieto() devuelve nada mtodo muertito() devuelve nada mtodo comer(Comida) devuelve nada ... otros comportamientos ...

crear Fido: mtodo buscar() devuelve rama Fido.sexo = macho Fido.color = marrn crear Princesa: Princesa.sexo = hembra Princesa.color = blanco Princesa.nombre = alma

Aspectos fundamentales de la programacin orientada a objetos

Encapsulacin Polimorfismo Identidad Clasificacin Herencia

Como Programar Descomposicin algortmica versus orientada a objetos

Encapsulamiento

Como Programar Descomposicin algortmica versus orientada a objetos

Abstraccin

Como Programar Descomposicin algortmica versus orientada a objetos

Clasificacin

Caractersticas de los objetos

Que es y que no es una clase

Como Programar Descomposicin algortmica versus orientada a objetos

Distintas Clasificaciones

Definiciones
Clase: Conjunto de objetos que comparten una estructura comn y un comportamiento comn. Interfaz: Proporciona una visin externa y por tanto enfatiza la abstraccin a la vez que oculta su estructura y los secretos de su comportamiento. Mtodo: Son funciones miembro del objeto, estn embebidas en el mismo. Instanciar: Se dice que una clase est instanciada cuando se ha creado un objeto de la misma. Herencia: Las clases pueden heredar ciertos comportamientos y caractersticas de otras. Clase base vs. Clase derivada: Cuando se hereda de una clase a otra clase, la clase padre de denomina Clase base y la que ha heredado se la denominar clase derivada. Polimorfismo: Se denomina polimorfismo a la capacidad de un mtodo de adquirir distintos comportamientos en funcin de los datos con los que se lo invoca. Sobrecarga (de operadores): Es la posibilidad de redefinir el comportamiento de los operadores con el nuevo objeto, es como asignar una funcin o mtodo a un operador.

Que es una interface

Clases base y derivadas

Anlisis orientado a objetos

Anlisis orientado a objetos

1. Identificacin de clases y objetos: Mediante un anlisis del comportamiento para identificar abstracciones que estn directamente relacionadas con los puntos funcionales del sistema. 2. Identificacin de semntica entre clases y objetos: Es establecer el comportamiento y atributos de cada abstraccin que se identifica en la fase previa. Aqu se refinan las abstracciones candidatas mediante una distribucin inteligente y medible de responsabilidades. En C++ el ejemplo de salida sern los headers. 3. Identificacin de relaciones entre clases y objetos: En esta etapa se consolidan las fronteras entre las abstracciones realizadas y se reconocen los colaboradores. Los principales productos de este paso son los diagramas de clases. 4. Especificacin de interfaces e implantacin de clases: Se proporciona un refinamiento de las abstracciones existentes, suficiente para descubrir nuevas clases y objetos del siguiente nivel de abstraccin, que se introducen entonces en la siguiente iteracin del anlisis.

Analogas
variables -> propiedades funciones -> mtodos Definir una variable -> Instanciar
(Se instancia una clase creando un objeto)

Implementacin de una funcin -> Implantar :: -> Miembro de : . -> Clase derivada de -> Invocacin de una funcin miembro

Clase2

Definicin de una clase C++

Modificadores de acceso (Encapsulamiento): Nos permiten definir que ser accesible desde fuera de la clase (public) y que ser accesible solo desde dentro de la misma (private). Existe una tercer posibilidad que es que solo lo vean las funciones derivadas y amigas (protected).

Ejemplo:
#include <iostream.h> /* Definicion de la clase */ class box { private: int length; int width; public: box(void); //Constructor ~box(void); //Destructor void set(int new_length, int new_width); int get_area(void) {return (length * width);} protected: my_pointer(); };

struct
El lenguaje C++ extendi la palabra clave struct de C otorgndole el mismo significado que a class pero con la diferencia de que todos sus miembros son pblicos (public) por defecto a diferencia de class que los declara como privados.

modificadores de acceso

Ejemplos de acceso Clases Externas

class perro { } class gato { perro pepe; pepe.xxx

// CLASE EXTERNA // Solo puedo acceder mtodos // o propiedades declaradas // como public

Ejemplos de acceso Clases Derivadas

class base { } class derivada : base { base A; A.xxx // : significa Derivada de:

// CLASE DERIVADA // Puedo acceder mtodos // o propiedades declaradas // como public o protected

Ejemplos de acceso Clases Miembro

class rectangulo { private: set_la(_) set_lb(_) protected: public: ingresar_forma (la,lb); } class rectangulo :: ingresar_forma (int la, int lb) // :: significa Miembro de: { set_la(_); //Miembro de la misma clase { // Puedo acceder mtodos // o propiedades declaradas // como public, protected o private

Contructores y Destructores
Instanciamiento: Cuando se instancia una clase, se llama a su constructor, y al terminar de usarla a su destructor. Para definir un constructor se define un mtodo con el mismo nombre de la clase, y para su destructor tambin el nombre pero precedido por el smbolo ~ Los constructores y destructores debe declararlos siempre como Pblicos. #include <iostream.h> /* Definicion de la clase */ class box { private: int length; int width; public: box(void); //Constructor ~box(void); //Destructor void set(int new_length, int new_width); int get_area(void) {return (length * width);} protected: my_pointer(); }; //Constructor box::box(void) { length = 8; width = 8; } //Destructor box::~box(void) { length = 0; width = 0; }

this
La palabra clave this representa dentro de una clase la direccin de memoria del objeto que se est ejecutando. Es un puntero, cuyo valor es la direccin del objeto.
Ejemplo:
#include <iostream.h> class CDummy { public: int soy_yo (CDummy& param); }; int CDummy::soy_yo (CDummy& param) { if (&param == this) return 1; else return 0; } int main () { CDummy a; CDummy* b = &a; if ( b->soy_yo(a) ) cout << si, &a es b"; return 0; }

static member data

Una clase puede contener miembros static, ya sean datos o funciones. A los datos de una clase definidos como static se los conoce como variables de la clase, ya que mantienen un valor comn para todos los objetos de la misma clase.
#include <iostream.h> class CDummy { public: static int n; CDummy () { n++; }; ~CDummy () { n--; }; }; int CDummy::n=0; int main () { CDummy a; CDummy b[5]; CDummy * c = new CDummy; cout << a.n << endl; delete c; cout << CDummy::n << endl; return 0; }

OUTPUT: 7 6

static member function

A las funciones de una clase definidas como static se las puede invocar aun cuando no haya objetos de la clase. Existen en la clase, no en los objetos.
#include <iostream.h> class Cat { public: Cat(int age) { itsAge = age; HowManyCats++; } ~Cat() { HowManyCats--; } int GetAge() { return itsAge; } void SetAge(int age) { itsAge = age; } static int GetHowMany() { return HowManyCats; } private: int itsAge; static int HowManyCats; }; int Cat::HowManyCats = 0; void TelepathicFunction(); int main() { const int MaxCats = 5; Cat *CatHouse[MaxCats]; int i; for (i = 0; i<MaxCats; i++) { CatHouse[i] = new Cat(i); TelepathicFunction(); } for ( i = 0; i<MaxCats; i++) { delete CatHouse[i]; TelepathicFunction(); } return 0; } void TelepathicFunction() { cout << "There are " << Cat::GetHowMany() << " cats alive!\n"; }

Polimorfismo
Definicin Polimorfismo: "el mecanismo que permite definir e Invocar funciones idnticas en denominacin e interfaz, pero con implementacin diferente". Dos funciones pueden tener el mismo nombre, pero:
El tipo de sus argumentos difieren La cantidad de sus argumentos difieren

Dos tipos:
Sobrecarga de funciones Sobrecarga de operadores

Sobrecarga de Funciones
#include "iostream.h"
// overload do_stuff; // This squares an integer // This squares an integer

int do_stuff(const int in_value) { return in_value * in_value; }

// Triples a float & return int

int do_stuff(const int);

// This triples a float & returns int

int do_stuff(float);
// This averages two floats

float do_stuff(const float, float); main() { int index = 12; float length = 14.33; float height = 34.33;

int do_stuff(float in_value) { return (int)(3.0 * in_value); }

// This averages two floats

float do_stuff(const float in1, float in2) { return (in1 + in2)/2.0; }

cout << "12 squared is " << do_stuff(index) << "\n"; cout << "24 squared is " << do_stuff(2 * index) << "\n"; cout << "Three lengths is " << do_stuff(length) << "\n"; cout << "Three heights is " << do_stuff(height) << "\n"; cout << "The average is " << do_stuff(length,height) << "\n"; }

// Result of execution 12 squared is 144 24 squared is 576 Three lengths is 42 Three heights is 102 The average is 24.330002

Sobrecarga de Operadores
Expresin @a a@ a@b a@b a(b, c...) a->b Operador (@) + - * & ! ~ ++ -++ -+ - * / % ^ & | < > == != <= >= << >> && || , = += -= *= /= %= ^= &= |= <<= >>= [ ] () -> Funcin Miembro A::operator@() A::operator@() A::operator@(B) A::operator@(B) A::operator()(B, C...) A::operator->()

Clase Compleja
class complex { private: float x, y; float sqr(float,float); public: complex() { x=0; y=0; } complex(float i,float j) { x=i; y=j; } void set(float i,float j) { x=i; y=j; } void print(); float modulo(); void operator= (complex ob2); complex operator+ (complex ob2); complex operator- (complex ob2); complex operator* (complex ob2); complex operator/ (complex ob2); };

Clase Compleja
float complex::sqr(float n1,float n2) { return (n1*n1+n2*n2)); } void complex::print() { cout << "(" << x << "," << y << ")"; } float complex::modulo() { return sqrt((double)(x*x+y*y)); } complex complex::operator+ (complex ob2) { complex temp; temp.x = x + ob2.x; temp.y = y + ob2.y; return temp; } void complex::operator= (complex ob2) { complex temp; x = ob2.x; y = ob2.y; } complex complex::operator* (complex ob2) { complex temp; temp.x = (x*ob2.x)-(y*ob2.y); temp.y = (x*ob2.y)+(y*ob2.x); return temp; } complex complex::operator- (complex ob2) { complex temp; temp.x = x - ob2.x; temp.y = y - ob2.y; return temp; }

Clase Compleja
complex complex::operator/ (complex ob2) { complex temp; temp.x = ((x*ob2.x)+(y*ob2.y))/sqr(ob2.x,ob2.y); temp.y = ((y*ob2.x)-(x*ob2.y))/sqr(ob2.x,ob2.y); return temp; } void main() { char c; for(int j=0;j<25;j++) { cout << endl; } complex A(1,2),B(3,4); cout << "Modulo de A: " << A.modulo() << endl; cout << "Modulo de B: " << B.modulo() << endl; A=B; cout << "Modulo de A: " << A.modulo() << endl; cout << "Modulo de B: " << B.modulo() << endl; cout << "Presione una tecla..."; c=cin.get(); }

Sobrecarga de operadores
Class Int { operator + (Int); operator + (Float); } Class Float { operator + (Float); operator + (Int); } Int A; // Int int Float F; String S; A + F; A + F; // (1) // Sobrecargo el + del Int // Osea estoy usando (1) // Sobrecargo el + del Float // Osea estoy usando (2)

// (2)

Seguir desarrollando

Clases Derivadas
#include <iostream.h> class CPolygon { protected: int width, height; public: void set_values (int a, int b) { width=a; height=b;} }; class CRectangle: public CPolygon { public: int area (void) { return (width * height); } }; class CTriangle: public CPolygon { public: int area (void) { return (width * height / 2); } }; int main () { CRectangle rect; CTriangle trgl; rect.set_values (4,5); trgl.set_values (4,5); cout << rect.area() << endl; cout << trgl.area() << endl; return 0; }

Herencia Mltiple
#include <iostream.h> class CPolygon { protected: int width, height; public: void set_values (int a, int b) { width=a; height=b;} }; class COutput { public: void output (int i); }; void COutput::output (int i) { cout << i << endl; } class CRectangle: public CPolygon, public COutput { public: int area (void) { return (width * height); } }; class CTriangle: public CPolygon, public COutput { public: int area (void) { return (width * height / 2); } }; int main () { CRectangle rect; CTriangle trgl; rect.set_values (4,5); trgl.set_values (4,5); rect.output (rect.area()); trgl.output (trgl.area()); return 0; }

Operadores new & delete

En C++ para tomar memoria se utiliza el operador new (malloc), y para devolverla al sistema el operador delete (free).

pointer = new type; pointer = new type [elements];

delete pointer; delete [] pointer;

#include <iostream.h> #include <stdlib.h> int main () { char input [100]; int i,n; long * l, total = 0; cout << Cuantos nmeros desea ingresar? "; cin >> i; l= new long[i]; if (l == NULL) exit (1); for (n=0; n<i; n++) { cout << Nmero: "; cin.getline (input,100); l[n]=atol (input); } cout << Usted ingreso: "; for (n=0; n<i; n++) cout << l[n] << ", "; delete[] l; return 0; }

Entrada / Salida en C++

Iostream.h : Definicin de objetos de entrada (cin) y salida (cout), es estndar del ANSI C++, ambos son streams y heredan de la clase base ios.
Operador >> para cin y << para cout sobrecargado para los siguientes tipos: int, long, double, float, char, y char* (string).

ios istream (cin) ostream (cout) filebuf

istream::gcount istream::get istream::getline istream::ignore istream::istream

istream::peek istream::putback istream::read istream::seekg istream::tellg

ostream::flush ostream::ostream ostream::put ostream::seekp ostream::tellp ostream::write

Archivos en C++

http://www.cplusplus.com/ref/

Archivos en C++
ofstream: Clase para operaciones de escritura (derivada de ostream) ifstream: Clase para operaciones de lectura (derivada de istream) fstream: Clase para operaciones de lectura y escritura (derivada de iostream)
ios::in ios::out ios::app ios::trunc ios::binary Abre un archivo para lectura Abre un archivo para escritura Abre para escritura al final del archivo Si el archivo existe lo pisa Modo binario

void open (const char * nom_arch, openmode modo); arch.open (ejemplo.bin", ios::out | ios::app | ios::binary); Se puede chequear si el archivo fue abierto llamando a la funcin miembro: bool is_open(); void close (); istream& write ( char * buffer, streamsize size ); ostream& read ( char * buffer, streamsize size );

Archivos en C++
Ejemplo
// Escribiendo un archivo de texto #include <fstream.h> int main () { ofstream arch_ej (ejemplo.txt"); if (arch_ej.is_open()) { arch_ej << Esto es una lnea.\n"; arch_ej << Otra lnea.\n"; arch_ej.close(); } return 0; } // Leyendo un archivo #include <iostream.h> #include <fstream.h> #include <stdlib.h> int main () { char buffer[256]; ifstream arch_ej (ejemplo.txt"); if (! arch_ej.is_open()) { cout << Error al abrir el archivo"; exit (1); } while (! arch_ej.eof() ) { arch_ej.getline (buffer,100); cout << buffer << endl; } return 0; }

Archivos en C++
Movindose dentro de un archivo
ios::beg ios::cur ios::end Es desplazamiento es desde el principio del archivo. Es desplazamiento es desde la posicin actual del archivo. Es desplazamiento es desde el fin del archivo.

tellg() and tellp() Estos dos miembros retornan un valor de tipo pos_type que es un tipo de dato entero que representa la posicin actual. En el caso de tellg() ser para la lectura y tellp() para la escritura. seekg() and seekp() Este par de funciones permiten cambiar la posicin actual del puntero de lectura y escritura sobre el archivo. Las mismas estn sobrecargadas y tienen dos prototipos.
seekg ( pos_type position ); seekp ( pos_type position );
Usando este prototipo se cambia la posicin tomando como referencia el principio del archivo.

seekg ( off_type offset, seekdir direction ); seekp ( off_type offset, seekdir direction );

Archivos en C++
Ejemplo
// Obtener el tamao de un archivo #include <iostream.h> #include <fstream.h> const char * nom_arch = ejemplo.txt"; int main () { long l,m; ifstream archivo (nom_arch, ios::in|ios::binary); l = archivo.tellg(); archivo.seekg (0, ios::end); m = archivo.tellg(); archivo.close(); cout << El tamao de " << nom_arch; cout << " es " << (m-l) << " bytes.\n"; return 0; } // Leyendo un archivo binario #include <iostream.h> #include <fstream.h> const char * nom_arch = ejemplo.txt"; int main () { char * buffer; long size; ifstream archivo (nom_arch, ios::in|ios::binary|ios::ate); size = archivo.tellg(); archivo.seekg (0, ios::beg); buffer = new char [size]; archivo.read (buffer, size); archivo.close(); cout << El archivo completo est en el buffer"; delete[] buffer; return 0; }