POO en C++: Sintaxis En el .h debe aparecer la declaración de la clase: class NombreClase { private: // atributos y métodos privados public: // atributos y métodos públicos }; Podemos declarar métodos inline. El código aparece junto a la declaración. No hace falta especificar la palabra inline en presencia de métodos.

POO en C++: Sintaxis En el .cpp la implementación de los métodos que no sean inline. tipo NombreClase::nombreMetodo(lista parámetros){ //implementación del método } private: no accesible desde fuera de la implementación de la clase. public: accesible desde fuera de la implementación de la clase.

POO en C++: Ejemplo UTablaGlobos.h class tTablaGlobos { private: int max; // dimensión del array dinámico tGlobo* tabla; // array dinámico int numGlobos; // número de globos del array .............. bool buscaPos(const tGlobo& g, int &pos) ; public: //constructora y destructora ......... // métodos bool ponElem(const tGlobo& g) ; ........ };

POO en C++: Ejemplo UTablaGlobos.cpp bool tTablaGlobos::ponElem(const tGlobo& g){ ...... } .......

POO en C++: Constructoras Las constructoras sirven para inicializar los atributos de un objeto. Su sintaxis es: NombreClase(lista parámetros); La implementación puede ser inline o ir al .cpp: NombreClase::NombreClase(lista parámetros){ // implementación de la constructora }

POO en C++: Constructoras La constructora por defecto (sin argumentos) cumple lo siguiente: Si no existe ninguna otra constructora para la clase, existe una por defecto (aunque no esté definida) que inicializa los atributos de la clase. Si existe alguna otra constructora definida, estamos obligados a definir la constructora por defecto si la queremos utilizar. NOTA: Como norma a seguir definiremos siempre la constructora por defecto.

POO en C++: Ejemplo .h tTablaGlobos(){ max=0; nGlobos=0; tabla=NULL; } tTablaGlobos(int nGlobos); .cpp void tTablaGlobos::tTablaGlobos(int nGlobos){ max=nGlobos; numGlobos=0; if(max>0) tabla = new tGlobo[max]; else tabla=NULL;}

POO en C++: constructoras La constructora por copia realiza una copia de un objeto en el objeto actual (this). NombreClase(const NombreClase& objeto); Cada clase tiene una constructora de copia por defecto. Pero conviene que, siempre que queramos utilizarla, nos la definamos nosotros mismos.

POO en C++: Un ejemplo tTablaGlobos(const tTablaGlobos& t){ numGlobos=t.numGlobos; max=t.max; if(max>0) tabla = new tGlobo[max]; else tabla=NULL; for (int i=0; i<t.numGlobos; i++){ ponElem(t.tabla[i]); }

POO en C++: constructoras La constructora por copia se ejecuta cuando se la invoca directamente para crear un objeto o cuando se hace paso de parámetros por valor. // t2 es un objeto de la clase tTablaGlobos tTablaGlobos t1(t2); void funcion(tTablaGlobos t2){....} f(t1);

POO en C++: destructora Todas las clases deben llevar asociada una destructora que destruya todo lo que la clase haya creado (con new). ~NombreClase(); Pueden ser inline o definirse el .cpp: NombreClase::~NombreClase(){ // implementación }

POO en C++: Un ejemplo .h ~tTablaGlobos(); .cpp void tTablaGlobos::~tTablaGlobos(){ if (tabla!=NULL){ delete [] tabla; tabla=NULL; max=0; numGlobos=0; }

POO en C++: Un ejemplo class Racional{ private: int num; int den; int mcd(int a, int b); public: // constructoras Racional(int n=0, int d=1){num=n; den=d;}; Racional(const Racional& r){num=r.num; den=r.den;} // destructora ~Racional(){num=0; den=1;}

POO en C++: Un ejemplo // operaciones de consulta int dameNumerador(){return num;}; int dameDenominador(){return den;}; // operaciones modificadoras void simplifica(); void suma(const Racional& r); //this=this+r void resta(const Racional& r); //this=this-r void divide(const Racional& r); //this=this/r void multiplica(const Racional& r); //this=this*r };

POO en C++: Un ejemplo class RacionalP{ private: int* num; int* den; Podríamos tener la clase Racional como: class RacionalP{ private: int* num; int* den; int mcd(int a, int b); public: // constructoras RacionalP(int n=0, int d=1){ num=new int; den=new int; *num=n; *den=d;}; RacionalP(const Racional& r){ num=new int;den=new int;*num=*(r.num);*den=*(r.den);}

POO en C++: Un ejemplo // destructora En este caso, la destructora tendría que ser: // destructora ~RacionalP(){ delete num; num=NULL; delete den; den=NULL; }

Declaración y creación de objetos Para declarar objetos: NombreClase obj; Declara obj como objeto de la clase NombreClase y lo crea invocando a la constructora por defecto, i.e., se inicializan los argumentos de obj de acuerdo según indique la constructora por defecto. NombreClase obj(argumentos); Declara obj como objeto de la clase NombreClase y lo crea invocando a la constructora que encaje con los argumentos. NombreClase* obj; Declara un puntero obj a un objeto de la clase NombreClase. Para crearlo: obj=new NombreClase(argumentos);

Declaración y creación de objetos { Racional r1(3,5); // automática o estática Racional r2(4,3); // automática o estática r1.suma(r2); // r1=r1+r2 Racional* r3=new Racional(5,7); // dinámica RacionalP r4(5,7); // automática o estática r3->suma(r3); // MAL r3->suma(r1); r3->suma(*r3); delete r3; // en otro caso BASURA!! r3=NULL; }

Declaración y creación de objetos Al ejecutar delete sobre un puntero a un objeto, se invoca a la destructora del objeto, además de liberar la memoria ocupada por éste. RacionalP* r = new RacionalP(2,3); r 2 3 delete r; Invocamos a la destructora r r

Constructora por copia RacionalP* r1=new RacionalP(5,7); RacionalP* r2=new RacionalP(*r1); Racional* r3=new Racional(2,4); Racional r4(*r3); RacionalP r5(3,4); RacionalP* r6=new RacionalP(r5); delete r1; r1=NULL; delete r2; r2=NULL; delete r3; r3=NULL; delete r6; r6=NULL;

Constructora por copia La constructora por copia se ejecuta siempre que sea necesario hacer una copia del objeto, en particular cuando tenemos métodos cuyo parámetro es un objeto de la clase y es de entrada (no puntero). void Racional::suma(const Racional& r); Racional r(3,4); Racional s(5,7); r.suma(s); // no se hace copia void Racional::suma(Racional r); r.suma(s); // se hace copia

Constructora por copia void RacionalP::suma(RacionalP* r); racionalP* r=new RacionalP(2,3); racionalP* s=new RacionalP(4,5); r->suma(s); // no se hace copia