Herencia de estructuras en C++

1. ¿Qué es la herencia en C++?
2. Tipos de herencia en C++
3. Herencia de estructuras en C++

Las estructuras y las clases son similares, pero la diferencia radica en su accesibilidad a otras clases o funciones en la programación orientada a objetos.

Las estructuras se especifican de forma predeterminada como públicas, mientras que las clases son privadas. Y en la herencia, no podemos heredar clases específicas privadas; tenemos que declarar manualmente una clase pública, mientras que las estructuras son públicas de forma predeterminada, por lo que podemos heredarlas fácilmente.

¿Qué es la herencia en C++?

La herencia es uno de los conceptos centrales de la Programación Orientada a Objetos, y la razón detrás de esto es que mejora la reutilización del código y la creación de clasificación jerárquica.

Con la ayuda de la herencia, puede definir una clase general que defina algunas funciones para realizar algunas operaciones básicas y extenderlas a otras clases para heredar esas funciones. Entendámoslo a través del diagrama.

En este ejemplo, tenemos Perro y Gato, y ambos son animales diferentes, pero al final, ambos pertenecen a la categoría de animal mascota.

Ambos tendrán las mismas funciones, como comer, dormir y caminar, que se pueden almacenar en la clase Mascota, también llamada clase base, mientras que las funciones específicas para ellos, como el sonido y el tamaño, se pueden definir en la clase Perro y Clase Cat, también llamada clase derivada.

Y este tipo de herencia se conoce como Herencia Única. Hay otros tipos diferentes que discutiremos uno por uno a continuación.

Ejemplo de código:

#include <iostream>
using namespace std;

// Base class
struct Pet {
  void eat() { cout << "I can eat i am pet \n"; }
  void sleep() { cout << "I can sleep i am pet \n"; }
  void walk() { cout << "I can walk i am pet \n"; }
};
// Derived class
struct Cat : Pet {
  void sound() { cout << "I am a cat Meow Meow! \n"; }
};
// Derived class
struct Dog : Pet {
  void sound() { cout << "I am a dog Bark Bark! \n"; }
};

int main() {
  cout << "This is Cat's characteristics" << endl;

  Cat myCat;
  myCat.eat();
  myCat.sleep();
  myCat.walk();
  myCat.sound();

  cout << "\nThis is Dog's characteristics" << endl;

  Dog myDog;
  myDog.eat();
  myDog.sleep();
  myDog.walk();
  myDog.sound();
}

Producción :

This is Cat's characteristics
I can eat i am pet
I can sleep i am pet
I can walk i am pet
I am a cat Meow Meow!

This is Dog's characteristics
I can eat i am pet
I can sleep i am pet
I can walk i am pet
I am a dog Bark Bark!

En este ejemplo, Mascota es una clase base donde Gato y Perro son clases derivadas. Pet ha definido algunos comportamientos comunes de gatos y perros, por lo que no los definimos en todas las clases para evitar la redundancia de código.

Perro y Gato amplían esos comportamientos comunes y definen su comportamiento específico en sus propias clases derivadas.

Las clases Perro y Gato tienen un solo comportamiento, sonido(), mientras que el otro proviene de la clase base. Y el objeto de estas clases derivadas es usar las otras funciones de la clase base.

Tipos de herencia en C++

C++ admite diferentes tipos de herencia, lo que brinda una opción abierta para usar cada uno según el escenario. Echemos un vistazo a cada uno por uno.

1. Herencia única
2. Herencia múltiple
3. Herencia multinivel
4. Herencia jerárquica
5. Herencia híbrida

Herencia Única

En herencia simple, tenemos una clase base y una clase derivada. Este tipo ya está explicado en el primer ejemplo.

Sintaxis:

class derivedClass_name : access_mode base_class {
  // body of the derived class
};

Herencia múltiple

En la herencia múltiple, podemos heredar la función y las propiedades de más de una clase base en una única clase derivada.

Sintaxis:

class derivedClass_name : access_mode base_class1,
                          access_mode base_class2,
                          ....{
  // body of the derived class
};

Herencia de varios niveles

Cada tipo de herencia le permite heredar de una clase base, pero la herencia multinivel tiene algo más que eso. Le permite hacer una herencia de varios niveles, lo que le permite heredar de la clase derivada a otras subclases.

Animals y pets son clases base, y cat es la clase derivada que hereda funciones y propiedades de ambas clases base.

Herencia jerárquica

En la herencia jerárquica, se heredan más de una subclase de una sola clase base en una jerarquía. Y también, se crea más de una clase derivada a partir de una sola clase base.

Este es un tipo avanzado de herencia.

herencia híbrida

Como se conoce por su nombre de herencia híbrida, este tipo de herencia comprende más tipos diferentes de herencia, como herencias jerárquicas y múltiples. Se puede hacer cualquier combinación para la herencia híbrida.

En este ejemplo, tenemos dos tipos diferentes de herencia, herencia única y herencia jerárquica, hecha como una herencia híbrida.

Herencia de estructuras en C++

En C++, una estructura es una palabra clave que se usa para definir una estructura similar a una clase pero con pequeñas diferencias. La principal diferencia entre una estructura y una clase es que los miembros de una estructura son públicos de forma predeterminada, mientras que la clase es privada, lo que genera problemas de seguridad.

Una estructura no es muy segura porque las funciones y propiedades no están ocultas para los usuarios finales. Por otro lado, las clases son seguras porque pueden ocultar implementaciones de programación de los usuarios finales.

Sintaxis general de la estructura:

struct structureName {
  member1;
  member2;
  ..memberN;
};

Dado que la herencia es una característica central de la programación orientada a objetos, las estructuras también pueden usar esta característica. La herencia con estructura necesita la palabra clave struct en lugar de clase.

Herencia de estructuras en C++:

#include <iostream>
using namespace std;

// Base class
struct Pet {
  void eat() { cout << "I can eat i am pet \n"; }
};

struct Dog : Pet {
  void sound() { cout << "I am a dog Bark Bark! \n"; }
};

int main() {
  cout << "\nThis is Dog's characteristics" << endl;
  Dog myDog;
  myDog.eat();
  myDog.sound();
}

Producción :

This is Dog's characteristics
I can eat i am pet
I am a dog Bark Bark!

Hemos usado la palabra struct antes del nombre de la estructura; se ve similar a las clases si notó que no habíamos usado la palabra público en el cuerpo de la estructura porque la estructura es pública por defecto.