Desarrollos de Programación en C- clases derivadas

Vista previa del material en texto

CLASES DERIVADAS
Introducción
Es un mecanismo para añadir recursos a una clase existente sin reprogramar ni recompilar. Es posible proveer una interfaz común para varias clases distintas
Se introduce el concepto de función virtual: permite utilizar objetos cuando su tipo no se conoce en el momento de la compilación
Es el modo de representar relaciones entre objetos: relaciones jerárquicas ó todo aquello que tienen en común dos o más clases
Clases derivadas
class empleado {
char* nombre;
short edad;
short departamento;
public :
empleado* siguiente; // público para poder
 //	manipular listas
void imprimir() const;
};
// a continuación se define la clase derivada gerente
class gerente : public empleado {
empleado* grupo
short nivel;
public :
void imprimir const;
};
La clase gerente tiene los miembros de la clase base empleado (nombre, edad, etc.) y además los miembros grupo y nivel. La derivación se representa gráficamente como :
empleado
gerente
Las relación entre las clases derivadas y las clases base se conoce como una relación de herencia. Es frecuente referirse a la clase base como la superclase y a la clase derivada como la subclase
Creación de una lista de empleados y gerentes :
void f()
{
gerente g1, g2;
empleado e1, e2;
empleado* listae;
listae = &g1; 		 //coloca a g1 en listae
g1.siguiente = &e1;	//coloca a e1 en listae
e1.siguiente = &g2;	// g2 en listae
g2.siguiente = &e2;	// e2 en listae
e2.siguiente = 0 ;		//termina listae
}
Como un gerente es un empleado se puede utilizar un gerente* de manera equivalente a un empleado*, a la inversa no es posible, un empleado* no se puede emplear como un gerente*.
void g()
{
 gerente gg;
 empleado* pe =≫ // correcto, gerente es empleado
 empleado ee;
 gerente* pg = ⅇ // error, empleado no es gerente
 pg->nivel = 2; 	// error ee no tiene espacio para nivel
 pg = (gerente*) pe; // correcto porque apunta al
 // gerente gg
 pg->nivel = 2;	// correcto
}
FUNCIONES MIEMBROS
Un miembro de la clase derivada puede utilizar un nombre público de la clase base. Un miembro de la clase derivada no tiene permiso para acceder a un miembro privado de la clase base
void gerente::imprimir() const
{
cout<<” el nombre es ”<< nombre <<’\n’;
}
En el caso de esta función el compilador la rechaza porque esta accediendo a un miembro privado de la clase base empleado
Si existiera la posibilidad de que un clase derivada accediera a un miembro privado, el concepto de miembro privado dejaría de tener significado : basta con definir una clase derivada para tener acceso a los miembros privados de cualquier clase. Cuando esto es necesario se declaran los miembros protegidos (“protected”) 
Declarando a los miembros de una clase como protected estos podrán ser vistos por las clases derivadas
Para solucionar esto podemos hacer :
void gerente::imprimir() const
{
empleado::imprimir(); // imprimir información empleados
cout<<” El nivel gerencial es ”<< nivel <<’\n’;
}
si se escribiera :
void gerente::imprimir() const
{
imprimir(); // secuencia recursiva de llamadas a funciones imprimir
}
Constructores y destructores
Algunas clases derivadas necesitan constructores. Si la clase necesita un constructor hay que llamarlo y además pasarle los argumentos si los tiene
class empleado{
...
...
public :
empleado(char* n, int d);
};
class gerente : public empleado {
...
...
public :
gerente(char* n, int l, int d);
};
Los argumentos de definición de la clase base se especifican en el constructor de la clase derivada :
gerente::gerente(char* n, int l, int d)
: empleado(n,d), nivel(l), grupo(0)
{
}
empleado::empleado(char* n, int d)
: nombre(n), departamento(d)
{
siguiente = lista
lista = this;
}
Cuando el compilador busca el miembro de una subclase, primero busca en el ámbito de la subclase, si no la encuentra lo busca en el ámbito de la superclase y así sucesivamente en la escala jerárquica de la herencia. Por este mecanismo es posible utilizar funciones miembros definidas en la superclase pero no redefinidas en la subclase
Los objetos de clase se construyen de abajo hacia arriba : primero la base, luego los miembros y después las clases derivada misma, y se destruyen en el orden opuesto.
Jerarquías de clase
Una clase derivada puede ser a su vez una clase base :
class empleado { ......};
class gerente : public empleado { .......};
class director : public gerente {......};
En general las estructuras jerárquicas son árboles pero pueden formar una estructura un poco más compleja como un grafo dirigido:
class temporal {.......};
class secretaria : public empleado {......};
class sectemp : public temporal, public secretaria {........};
class asesor : public temporal, public gerente {.......};
 temporal			 empleado
 sectemp	 secretaria		gerente
 asesor						director
Funciones virtuales
Permite al programador declara funciones en una clase base que se pueden redefinir en una clase derivada
class empleado {
char* nombre;
short departamento;
empleado* siguiente;
static empleado* lista;
public:
empleado(char* n, int d);
static void imprimir_lista;
virtual void imprimir() const;
};
La palabra clave virtual indica que la función imprimir() puede tener diferentes versiones para clases derivadas distintas y que es tarea del compilador encontrar la versión apropiada. 
El tipo de función se declara en la clase base y no pueden volver a declararse en una clase derivada. Las funciones virtuales deben definirse para la clase en la que se declaran por primera vez. Ejemplo :
void empleado::imprimir() const
{
cout<< nombre<< ‘\t’<< departamento <<’\n’;
}
Es posible utilizar la función virtual aunque no se derive ninguna clase, y no hace falta que una subclase que no necesite una función especial de una función virtual tenga que incluir una. Al derivar una clase uno puede preparar una función apropiada si es necesario.
class gerente : public empleado {
empleado* grupo
short nivel;
public :
void imprimir const;
};
Ya no se necesita en este caso la función de imprimir empleado porque la nueva función puede tomar su lugar.
Clases Abstractas
Esto se emplea para cuando existen conceptos abstractos para los que no existe objetos, como es el caso de figura. Una figura solo tiene sentido como base para cuando una clase se deriva de ella. Esto puede ser un buen campo para el empleo de funciones virtuales.
class figura {
// .....
public:
virtual void girar(int) { error(“girar::figura”)};
virtual void dibujar() { error(“dibujar::figura”)};
};
Tratar de crear una figura de esta especie es absurdo pero legal:
figura f;
Es absurdo porque una operación sobre f producirá un error.
Una alternativa es declarar las funciones virtuales de la clase figura como funciones virtuales puras. Una función virtual se “purifica” con un inicializador en 0 :
class figura {
// .....
public:
virtual void girar(int) = 0; // función virtual pura
virtual void dibujar() = 0; // función virtual pura
};
Una clase con una o más funciones virtuales puras es una función abstracta y no es posible crear objetos de esa clase, por lo tanto :
figura f; // error : variable de clase abstracta figura
Una clase abstracta solo puede servir como base para otra clase. Por ejemplo :
class circulo : public figura {
int radio;
public:
void girar(int) { ......}; // deroga a figura::girar
void dibujar(); // deroga a figura::dibujar
circulo(punto p, int r);
};
Las funciones virtuales puras que no están definidas en una clase derivada siguen siendo funciones virtuales puras, de modo que la clase derivada es también una clase abstracta. Esto permite hacer implementaciones por etapas:
class X {
public:
virtual void f()=0;
virtual void g()=0;
};
X b; //error declaración de objeto de clase abstracta X
class Y : public X {
void f(); // deroga a X::f
};
Y b ; //error declaración de objeto de clase abstracta Y
class Z : public Y {
void g(); // deroga a X:: g
};
Z c; // correcto
Herenciamúltiple
Ya se ha visto que es posible generar una clase a partir de más de una clase base, como por ejemplo :
class sectemp : public secretaria , public temporal {
.........
};
A esto se llama herencia múltiple. Además de las operaciones que se definen para una secretaria temporal es posible aplicarle las operaciones de los objetos secretaria y temporal
Puede ocurrir que en herencia múltiple una misma clase base pueda ser empleada dos veces. Por ejemplo :
X X
Y Z
W
En estos casos a veces no es posible hacer referencia a miembros de la clase X sin riesgo de ambigüedad.
 
Para resolver la ambigüedad se debe hacer :
class Y {
// ......
virtual f();
};
class Z{
//.......
virtual f();
};
al emplear W será necesario eliminar la ambigüedad :
void g(W* p){
{
i = p->f; //error : ambigüedad
i = p->Y::f; // correcto
i = p->Z::f; //correcto
};
 Resolución de ambigüedades en la clase derivada :
class W {
// ......
i1 = Y::f();
i2 = X::f();
};
Clases bases virtuales
Una clase base virtual sirve para representar una clase principal que se puede adaptar de diferentes maneras :
class ventana {
// lo básico
virtual void dibujar();
};
class ventana_con_ borde : public virtual ventana {
// cosas del borde
void dibujar();
};
class ventana_con_ menu : public virtual ventana {
// cosas del menu
void dibujar();
};
class ventana_con_ borde_y_menu : public virtual ventana,
public ventana_con_borde,
public ventana_con_menu {
void dibujar();
};
Ahora podemos escribir las distintas funciones dibujar :
void ventana_con_borde::dibujar() {
ventana::dibujar();
// dibujar el borde
}
void ventana_con_menu::dibujar() {
ventana::dibujar();
// dibujar el borde
}
void ventana_con_borde_y_menu::dibujar() {
ventana_con_borde::dibujar();
ventana_con_menu::dibujar();
// dibujar lo específico para ventana con borde y menú
}
Atención : se llama a dibujar ventana dos veces !!!!!!
Hay algunos métodos para corregir estos errores.
Control de acceso
Un miembro de una clase puede ser :
privado : puede ser accedido por funciones miembros y amigas
protegido : puede ser accedido por funciones miembros y amigas de la clase que se declara y por las miembros y amigas de las clases derivadas
público: cualquier función puede utilizar su nombre
Accesos a clases base
Los accesos a las clases bases también pueden ser privado protegido y público.
Class X {
public: 
int a:
};
class Y1 : public X {};
class Y2 : protected X{};
class Y3 : private X{};
Herencia pública :
público público
protegido protegido
privado privado
Herencia privada :
público privado
protegido privado
privado privado
Herencia protegida :
público protegido
protegido protegido
privado privado
Ejemplo:
class X {
// privado por omisión
	int priv;
protected:
	int prot;
public:
	int publ;
	void m();
};
El miembro X::m tiene acceso irrestricto
void X::m()
{
	priv=1; //correcto
	prot=2; //correcto
	publ=3; //correcto
}
Un miembro de la clase privada tiene acceso a los miembros públicos y protegidos:
class Y : public X {
	void mderivada();
};
Y::mderivada()
{
	priv=1; //error!! priv es privada
	prot=2; //correcto prot es protegida
	publ=3; //correcto publ es pública 
}
Una función global f() solo puede tener acceso a la parte pública :
void f(Y* p)
{
	p->priv=1; //error!! priv es privada
	p->prot=2; //error prot es protegida y f no es
// miembro o amiga de X ni de Y 
	p->publ=3; //correcto publ es pública }
Curso : Desarrollos de Programación en C++