Aprendiendo C/C++ Paso a Paso - Página 14

14. Paso a Paso C/C++ — Programación en C++ - Herencia

Herencia

| | Introducción
Clase derivada y Clase base
Especificando la Clase Derivada
Constructores de Clase Derivada
Especificadores de Acceso
Público
Privado
Protegido
Especificadores de Acceso sin Herencia
Especificador de Acceso Protegido
Ámbito de Especificadores de Acceso
Especificadores de Acceso con Herencia
Tipos de Herencia
Herencia Simple
Herencias Múltiples
Herencia Multinivel
Herencia Híbrida
Herencia Jerárquica |

Introducción

La herencia es la característica más poderosa de la programación orientada a objetos. La herencia es el proceso de crear nuevas clases, llamadas clases derivadas, a partir de clases existentes o clases base. La clase derivada hereda todas las capacidades de la clase base, pero puede agregar embellecimientos y refinamientos propios.
Una clase, llamada clase derivada, puede heredar las características de otra clase, llamada clase base.

Heredar las cualidades de la clase base a la clase derivada se conoce como herencia .
Su sustantivo es patrimonio. Sabemos que en nuestra vida diaria, usamos el concepto de clases que se derivan en subclases. Por ejemplo, Vehículo es una clase que se divide nuevamente en Bicicletas, Motocicletas, Autos, camiones, autobuses, etc.

Aquí, Vehículo se conoce como Clase base y los elementos derivados se conocen como clases derivadas o subclases. **

Generalmente, cada clase base tiene una lista de cualidades y características. El tema principal en esta herencia es compartir todas las características comunes de la clase base a las clases derivadas.

| | |

La herencia tiene una característica importante que permite la reutilización. Un resultado de la reutilización es la facilidad de distribuir bibliotecas de clases. Un programador puede usar una clase creada por otra persona o empresa y, sin modificarla, derivar otras clases de ella que se adapten a situaciones particulares.

Clase derivada y Clase base

Una clase, llamada clase derivada, puede heredar las características de otra clase, llamada clase base.
La clase derivada puede agregar otras características propias, por lo que se convierte en una versión especializada de la clase base. La herencia proporciona una forma poderosa de extender las capacidades de las clases existentes y de diseñar programas utilizando relaciones jerárquicas.

La accesibilidad de los miembros de la clase base desde las clases derivadas y desde los objetos de las clases derivadas es un tema importante. Los objetos de las clases derivadas pueden acceder a datos o funciones en la clase base que están precedidos por la palabra clave protegida desde las clases derivadas, pero no. Las clases pueden ser derivadas públicamente o privadamente de las clases base. Los objetos de una clase derivada públicamente pueden acceder a los miembros públicos de la clase base, mientras que los objetos de una clase derivada privadamente no pueden.

El diagrama muestra cómo la clase derivada hereda.

| | |

Una clase puede ser derivada de más de una clase base. Esto se llama herencias múltiples. Una clase también puede estar contenida dentro de otra clase.

Especificando la Clase Derivada

La declaración de clase es muy fácil usando la palabra clave class, así como la declaración de la clase derivada también es fácil, pero la clase debe terminar con su id de clase base y especificador de acceso.
Sintaxis para declarar una clase derivada:

Class lass_name>: ….

Por ejemplo, class resultado : public stud;

| | /  programa para aceptar y mostrar un registro de estudiante  /
#include
using namespace std;
class add
{
private :
char str[20];
char city[20];
int pin;
public :
void get_add()
{
cout << “Ingrese Dirección  calle, ciudad, pin”;
cin >> street >>city>>pin;
}
void put_data()
{
cout << “La dirección es   “ << str
<}
};
class stud  : public add
{
private :
int sno;
char name[20];
int m1,m2,m3;
public :
void get_data()
{
cout << “Ingrese Número de Estudiante  “; cin >> sno;
cout << “Ingrese Nombre de Estudiante  “; cin >> name;
cout << “Ingrese calificaciones de 3 materias  “;
cin >> m1 << m2 << m3;
}
void put_data()
{
cout  << “Número de estudiante  :” << sno;
cout << “Nombre de estudiante      :” << name;
cout << “Calificaciones de estudiante     :” << m1 << “  “ <}
};
int main()
{
stud s;
s.get_add();
s.get_data();
s.put_add();
s.put_data();
return 0;
} |

Explicación diagramada para el programa anterior

| | |

Constructores de Clase Derivada

Si una clase se declara con sus propios constructores, es una clase base de otra. La clase derivada también tiene sus propios constructores. Si se declara un objeto, ¿cuál constructor se ejecutará? No hay duda de que se ejecutará el constructor de la clase derivada. Si aún desea ejecutar el constructor de la clase base o ambos constructores de la clase derivada y la clase base, simplemente llame al constructor de la clase base en el constructor de la clase derivada.

| | / Constructores en clase derivada /
#include
using namespace std;
class Add
{
protected :                                // NOTA : no privado
unsigned int a;
public :
Add()  {  a = 0; }                  // constructor , sin args
Add( int c ) { a = c; }             // constructor , un args
int get_val(){     return a; }      // devuelve un valor A
Add operator ++ ()                  // incrementar cuenta
{
a++;                           // incrementar cuenta, devolver
return Add(a);                 // un objeto temporal sin nombre
}                                   // inicializado a esta cuenta
};

class Sub : public Add
{
public:
Sub() : Add() { }                     // Constructor, sin args
Sub(int c) : Add(c) { }               // Constructor, un args
Sub operator – ()                    // decrementar valor de A, devolver
{                                     // un objeto temporal sin nombre
a–;                             //inicializado a este valor
return Sub(a);
}
};
int main()
{
Sub ob1;                                  // clase Sub
Sub ob2(100);
cout << “\nOb1  =” << ob1.get_val();      // mostrar
cout << “\nOb2  =” << ob2.get_val();      // mostrar
ob1++; ob1++; ob1++;                      // incrementar ob1
cout << “\nOb1  =” << ob1.get_val();      // mostrar
ob2–; ob2–;                             // decrementar ob2
cout << “\nOb2  =” << ob2.get_val();      // mostrar
Sub ob3=ob2–;                            // crear ob3 a partir de ob2
cout << “\nOb3  =” << ob3.get_val();      // mostrar
return 0;
} |

ESPECIFICADORES DE ACCESO

Los especificadores de acceso se utilizan para controlar, ocultar, asegurar tanto los datos como las funciones miembro.  Los especificadores de acceso son de 3 tipos

1. Especificador de Acceso Público
2. Especificador de Acceso Privado
3. Especificador de Acceso Protegido.

Público :

| | Si un miembro o dato es público, puede ser utilizado por cualquier función dentro de la clase y sus clases derivadas también.
En C++, los miembros de una struct o union son públicos por defecto.
Los miembros públicos de una clase pueden ser heredados a la clase derivada cuando la clase se hereda públicamente, pero no las funciones miembro (privadamente). |

Privado :

| | Las funciones miembro y amigos de la clase en la que se declara solo pueden usarlo.
Los miembros de una clase son privados por defecto.
Los miembros privados de una clase no se heredan a una clase derivada cuando la clase base se hereda públicamente o privadamente. Si hay necesidad, debemos escribir funciones miembro que devuelvan esos valores. |

Protegido :

| | Se accede de la misma manera que para privado; además, el miembro puede ser utilizado por funciones miembro y amigos de clases derivadas de la clase declarada, pero no solo en objetos del tipo derivado.
El miembro protegido de una clase puede ser heredado a la siguiente clase derivada solamente. Pero no a las clases posteriores. |

Especificadores de Acceso sin Herencia

| | |

Más sobre el Especificador de Acceso Protegido

Para proporcionar la funcionalidad sin modificar la clase. Protegido puede ser accedido por sí mismo y miembros protegidos de la clase derivada solamente, pero en objetos o la subclase derivada o la clase externa.

Ámbito de los Especificadores de Acceso

| Especificador de Acceso | Accesible desde
Clase propia | Accesible desde
clase derivada | Accesible desde
Objetos fuera de la clase | | Público | Sí | Sí | Sí | | Protegido | Sí | Sí | No | | Privado | Sí | No | No |

Especificadores de Acceso con Herencia

| | |

Tipos de Herencia

| | |

| | |

| | / Programa para demostrar Herencia Múltiple /
#include
using namespace std;
class M
{
protected :
int m;
public :
void getm()
{
cout << “\nIngrese valor de M  :”;
cin >> m;
}
};
class N
{
protected :
int n;
public :
void getn()
{
cout << “\nIngrese valor de N  :”;
cin >> n;
}
};
class P : public N, public M
{
public :
void disp()
{
cout << “\n  M   =  “ << m;
cout << “\n  N   =  “ << n;
cout << “\n  MN =  “ << mn;
}
};
int main()
{
P p;
p.getm();
p.getn();
p.disp();
return 0;
} |

Si una clase base se hereda públicamente, entonces los miembros públicos, las funciones miembro pueden ser accesibles para las funciones miembro de la clase derivada y para los objetos también, mientras que si una clase base se hereda privadamente, entonces el miembro público de la clase base se hereda a las funciones miembro de la clase derivada solamente, pero no a los objetos.

| | / Un programa para demostrar Herencia Multinivel /
class student
{
int rno;
public:
void getrno()
{
cout << “Ingrese  Número :”;
cin >> rno;
}
void showrno()
{
cout << “Número de Estudiante:” << rno;
}
};
class test : public student
{
int m1,m2;
public :
void getmarks()
{
cout << “Ingrese calificaciones 1  :” ; cin >> m1;
cout << “Ingrese calificaciones 2  :” ; cin >> m2;
}
int  retm1()
{
return m1;
}
int retm2()
{
return m2;
}
};
class result : public test
{
int tot;
public:
void get()
{
getrno();
getmarks();
}
void showresult();
void show()
{
showrno();
showresult();
}
};
void result::showresult()
{
int s1,s2;
s1=retm1();
s2=retm2();
tot=s1+s2;
cout << “\nCalificaciones  “ << s1 << “  “ << s2;
cout << “\nTotal de calificaciones  “ << tot;
}
int main()
{
result a;
a.get();
a.show();
return 0;
} |

| | / Programa para demostrar Herencia Híbrida /
#include
using namespace std;
class student
{
int rno;
public:
void getrno()
{
cout << “Ingrese  Número :”;
cin >> rno;
}
void showrno()
{
cout << “ Número de Estudiante   :” << rno;
}
};
class test : public student
{
protected :
int m1,m2;
public :
void getmarks()
{
cout << “Ingrese calificaciones 1  :” ; cin >> m1;
cout << “Ingrese calificaciones 2  :” ; cin >> m2;
}
void showmarks()
{
cout << “ Calificaciones  de 2 materias ” << m1 << “  “ << m2;
}
};
class sports
{
protected :
int score;
public :
void getscore()
{
cout << “Ingrese   Puntaje  :”;
cin >> score;
}
};
class result : public test, public sports
{
public :
void getdata()
{
getrno();
getmarks();
getscore();
}
void putdata()
{
showrno();
showmarks();
cout << “ El puntaje  es  “ << score;
cout << “ Total de calificaciones   “ << m1+m2;
}
};
int main()
{
result  r;
r.getdata();
r.putdata();
return 0;
} |

Representación pictórica del programa anterior:

| | |

En la figura anterior, la clase estudiante se hereda a resultado de dos maneras.  Una es a través de test y la otra a través de deportes, luego dos conjuntos de miembros, funciones miembro de la clase base común estudiante se heredan a la clase derivada resultado. En el momento de la ejecución, el sistema se confundirá al usar qué conjunto de funciones miembro de la clase base.
Esto se puede evitar haciendo que la clase base común sea una clase base virtual.

Ej:

| | class student { };
class test : virtual public student { };
class sports : virtual public student { };
class result : public test, sports { }; |

Ref: Programación orientada a objetos en Turbo C++: Robert Lafore