esq_creaclase

=Esquemas=

Aqui encontrareis los esquemas básicos de las clases. Estos esquemas no tiene porque compilar, el objetivo es mostraros de forma rápida como se construyen clases.

Esquema de una clase Esquema de herencia Esquema de clase plantilla Esquema de clase plantilla que hereda de otra clase plantilla



Clase base
code format="cpp"
 * 1) ifndef _XXXXXXXXXXXXXX_H_
 * 2) define _XXXXXXXXXXXXXX_H_

namespace xxx { /**\brief Informacion class Clase { //Zona publica public: /**Constructor vacio */    Clase{} /**Constructor parametrizado */    Clase(int p1){ _p1=p1;} /**Se crea como una copia */    Clase(Clase &C){ _p1=C._p1;} /**Destructor. Esta es la ultima función. Es llamada automaticamente por el compilador al    * destruir el objeto. * Nunca debemos de llamarla */    ~Clase{   } /**Otras cosas */    void do{  .... } //Variable privadas private: int _p1;

};//end class };//end namespace
 * 1) endif

code

Clase que hereda de otra
code format="cpp" namespace xxx { /**\brief Informacion class Hija: [public | private] Clase { public: /**Constructor vacio. Llama al constructor del padre */   Hija:Clase {} /**Constructor parametrizado. Llama al constructor del parametrizado de Padre */   Hija(int p2,int p1):Clase(p1){}
 * 1) ifndef XYXYXYXYXYXY_H_
 * 2) define XYXYXYXYXYXY_H_
 * 3) include  //incluye al padre

/**Otro Constructor parametrizado. Llama al constructor vacio del Padre */   Hija(int p2,int p1):Clase{ _p2=p2;}

/**Constructor de copia. Llama al constructor de copia del Padre. El padre copiara los datos que son de él. *Luego, esta clase copia los suyos */   Hija(const Hija &H):Clase(H){ _p2=H._p2;} /**Destructor. El compilador se encarga de llamar al destructor del padre por nosotros. */  ~Hija{  } /** Redefine una función del padre y llama a la misma función del padre internamente */   void do{  ...; Clase::do; ....}

private: int _p2; };

};
 * 1) endif

code

Clase plantilla
code format="cpp"
 * 1) ifndef _PLANTILLA___XXX_H
 * 2) define _PLANTILLA___XXX_H

namespace xxxx{

template class PlantillaPadre {

public: /**Constructor */ PlantillaPadre{ _v=NULL; _n=0; }

/**Constructor Parametrizado */ PlantillaPadre(int n){ _v=new Type[n]; _n=n; } /**Constructor de copia */ PlantillaPadre(const PlantillaPadre &P){ _v=new Type[P._n]; _n=P._n; memcpy(_v,M._v,sizeof(Type)*_n); } /**Destructor */ ~PlantillaPadre{ if (_v!=NULL) delete []_v; } /**Acceso al elemento para ver y modificarlo. Se pasa una referencia al elemento */ Type &operator[](int i){ assert(i<_n); return _v[i]; } /**Funcion miscelanea. Hace lo que sea */ void do{ .... } private: Type *_v; int _n; }; }; code
 * 1) endif

Clase que hereda de plantilla
 code format="cpp" using namespace std; namespace xxxx{ template class Hijo: [public | private] PlantillaPadre { public: /**Constructor vacio. Llama al contructor vacio del padre y luego inicializa sus variables */  Hijo:PlantillaPadre{ _myVar=0; }
 * 1) ifndef _XXXXX_
 * 2) define _XXXXX_
 * 3) include  //incluye al padre

/** El constructor parametrizado, llama al constructor parametrizado del padre  y despues * inicializa sus variables */ Hijo(int myV,int n):PlantillaPadre(n){ _myVar=myV; }

/** El constructor de copia, llama al constructor de copia del padre y luego copia sus variables */ Hijo(const Hijo&H):PlantillaPadre(H){ _myVar=H._myVar; }

/**Destructor. El compilador se encarga de llamar al destructor del padre por nosotros. * NUNCA LLAMAREMOS A UN DESTRUCTOR. NUNCA!!! * Al destructor lo llamará el compilador automaticamente cuando sea necesario */ ~Hijo{ }

/**Funcion que llama internametne a una del padre */  void do2{......;  PlantillaPadre::do; ..... }

private: int _myVar; }; }; code
 * 1) endif