CLASES DERIVADAS HERENCIA La herencia o relacion esun

CLASES DERIVADAS: HERENCIA

� La herencia o relacion es-un es la relacion que existe entre dos clases, en la que una clase denominada se crea a partir de otras ya existente, denominada clase base. � La declaracion de la derivacion de clases debe incluir el nombre de la clase base de la que se deriva y especificador de acceso que indica el tipo de herencia(Publica, Privada y Protegida).

class nombre_clase : tipo_herencia nombre_clase_base class Triangulo : public Figura { public: //seccion publica ……. . private: //seccion privada …… };

� Considerese una clase Prestamo y tres clases derivadas de ella: Pago_fijo, Pago_variable e Hipoteca. � � � class Prestamo { protected: › › float capital; float tasa_interes; public: Prestamo( float, float); virtual int Crear. Tabla. Pagos(float[MAX_TERM][NUM_COLUMNAS])=C; }; Class Hipoteca : public Prestamo { private: int num_recibos; int recibos_por_anyo; float pago; public: Hipoteca(int, float, float); int Crear. Tabla. Pagos(float [MAX_TERN][NUM_COLUMNAS]); };

� Herencia publica: es aquella en que el especificador de acceso es public(publico). � Herencia privada: es aquella en que el especificador de acceso es private(privado). � Herencia protegida: es aquella en que el especificador de acceso es protected(protegido).

#include “fstring. h” class Publicacion { public: void Nombrar. Editor(const char *s); void Poner. Fecha(unsigned long fe); private: string editor; unsigned long fecha; }; class Revista : public Publicacion { public: void Numeros. Por. Anyo(unsigned n); void Fijar. Circulacion(unsigned long n); private: unsigned numeros. Por. Anyo; unsigned long circulacion; }; class Libro : public Publicacion { public: void Poner. ISBN(const char *s); void Poner. Autor(const char *s); private: Dstring ISBN; Dstring autor; };

Tipo de herencia Tipo de elemento ¿Accesible a clase derivada? Public protected private Si Si No Private public protected private Si Si No

� Significa que una clase derivada tiene acceso a los elementos públicos y protegidos de su clase base.

� Significa que un usuario de la clase derivada no tiene acceso a ninguno de sus elementos de la clase base. El formato es: class Clase. Derivada : private Clase. Base { public: //Sección publica Protected: //Sección privada Private: //sección privada };

� Los miembros públicos y protegidos de la clase base se convierten en miembros protegidos de la clase derivada y los miembros privados de la clase se vuelven inaccesibles.

Tipos de herencia Acceso a miembro base Acceso a miembro a clase derivada public protected private protected inaccesible private public protected private inaccesible

class Base{ public: int i 1; Protected: int i 2; Private: int i 3; }; class D 1 : private Base{ void f(); }; class D 2 : protected Base{ void g(); }; Class D 3 : public Base{ void h(); }; Void D 1: : f(){ i 1=0; //Correcto i 2=0; //Correcto i 3=0; //Error }; Base b; b. i 1=0; //correcto b. i 2=0; //Error b. i 3=0; //Error D 1 d 1; d 1. i 1=0; //Error d 1. i 2=0; //Error d 1. i 3=0; //Error D 2 d 2; d 2. i 1=0; //Error d 2. i 2=0; //Error d 2. i 3=0; //Error D 3 d 3; d 3. i 1=0; //Correcto d 3. i 2=0; //Error d 3. i 3=0; //Error

class D 4 : protected base{ public: base: : i 1; }; D 4 d 4; d 4. i 1=0; //correcto

class B 1{ public: B 1(){cout <<“C-B 1”<<endl; } }; class B 2{ public: B 2(){cout <<“C-B 1<<endl; } }; class D : public B 1, B 2{ public: D(){cout <<“C-D”<<endl; } }; D d 1; Sintaxis Clase. D: : Clase. D(Parametros) : Clase. B(Parametros), Lista. Mbr. D{ //Cuerpo del constructo };

Class Punto{ public: Punto(int xv, int yv); //… }; class Punto 3 D : public Punto{ public: Punto 3 D(int xv, int yv, int zv); void fijarz(); private: int z; }; Punto 3 D: : Punto 3 D(int xv, int yv, int zv) : Punto(xv, yv){ fijarz(zv); };

class C 1{ public: C 1(int n); ~C 1(); private: int *pi, l; }; C 1: : C 1(int n) : l(n){ cout <<l<<“ enteros se asignan”<<endl; } C 1: : ~C 1() { cout<<l<<“ enteros son liberados”<<endl; delete []pi; } Class C 2 : public C 1{ public: C 2(int n); ~C 2(); private: char *pc; int l; }; C 2: : C 2(int n) : C 1(n), l(n){ cout <<l<<“caracteres designados”<<endl; pc=new char[1]; } C 2: : ~C 2(){ cout <<l<<“caracteres son liberados”<<endl; delete []pc; } void main() { C 2 a(50), b(100); }