Herencia en C++: Crear Clases de Animales Especializadas

Curso de Programación Orientada a Objetos con C++

Memoria dinámica

Manejo de Memoria y Punteros en C++

Programación en C++: Manejo de Punteros y Memoria Dinámica

Uso de Punteros para Manipular Memoria en C++

Estructuras de datos

Creación de Estructuras de Datos Personalizadas en C++

Estructuras de Datos en C++: Implementación y Uso de Structs

Uniones y Enumeraciones en C++: Gestión Eficiente de Memoria

Introducción a la Programación Orientada a Objetos

Programación Orientada a Objetos en C++: Clases y Objetos Básicos

Propiedades y Métodos: Clases en Programación Orientada a Objetos

Ciclo de Vida de un Objeto en C++: Constructores y Destructores

Principios de la Programación Orientada a Objetos

Encapsulación en Programación Orientada a Objetos con C++

Puntero "this" en C++: Referencia a la Instancia de la Clase

Métodos y Atributos Estáticos en C++

Herencia en C++: Crear Clases de Animales Especializadas

Herencia Múltiple en C++: Implementación Práctica

Implementación de Polimorfismo en Programación Orientada a Objetos

Despedida

Programación Orientada a Objetos con C++ Avanzado

No tienes acceso a esta clase

¡Continúa aprendiendo! Únete y comienza a potenciar tu carrera

Si ya tienes una cuenta,

Recursos

¿Qué es la herencia en la programación orientada a objetos?

La herencia es una de las características más destacadas de la programación orientada a objetos. En C++, la herencia permite a las clases derivar características y comportamientos de una o más clases base, fomentando así la abstracción y relación entre entidades. Imaginemos un sistema en el que las personas puedan ser especializadas como estudiantes o profesores de Platzi. Estos ejemplos de especializaciones heredarían características de una clase base humana, como tener un nombre o una edad.

¿Cómo se implementa la herencia en C++?

Para implementar herencia en C++, se define una clase base que contiene propiedades y métodos que pueden ser heredados por otras clases. Aquí te mostramos cómo hacerlo mediante un ejemplo:

Definición de una clase base

Crearemos una clase Animal que servirá como base para otras especializaciones. Dentro de esta clase, manejaremos un contador de animales y un método para que los animales "coman".

class Animal {
protected:
    std::string alimento;
    static int numeroDeAnimales;

public:
    Animal() {
        númeroDeAnimales++;
        std::cout << "Creando un nuevo animal\n";
    }
    ~Animal() {
        númeroDeAnimales--;
        std::cout << "Borrando animal\n";
    }
    void comer() {
        std::cout << "El animal está comiendo " << alimento << " ñom ñom\n";
    }
};

Especialización mediante herencia

A continuación, vamos a crear una clase Herbívoro que heredará de Animal. Los herbívoros consumirán plantas o pasto de manera predeterminada.

class Herbivoro : public Animal {
public:
    Herbivoro() {
        alimento = "pasto";
    }
    void pastar() {
        std::cout << "Este animal está pastando\n";
    }
};

Uso de las clases especializadas

Podemos utilizar nuestra clase Herbivoro para crear instancias y utilizar métodos heredados o específicos.

int main() {
    Herbivoro h;
    h.pastar();
    h.comer();

    return 0;
}

¿Qué debemos considerar al usar herencia?

Visibilidad y acceso

Por defecto, los miembros de una clase en C++ son privados. Para permitir que las clases derivadas accedan a estos miembros, podemos declararlos como protected. Esto permite que las subclases accedan a ellos mientras permanecen inaccesibles desde fuera de la jerarquía de clases.

Herencia pública

Utilizar herencia pública en C++ es crucial cuando deseamos que los métodos y propiedades de la clase base sean accesibles desde las clases derivadas. Esto garantiza que las funcionalidades necesarias se hereden de manera adecuada.

Constructor y destructor

Es necesario explicitar qué constructor se tiene que utilizar cuando las clases derivadas se instancian. Esto se hace llamando al constructor de la clase base dentro de las definiciones del constructor de las clases derivadas, como en el caso del Herbivoro.

¿Cómo expandir las funcionalidades con herencia múltiple?

La herencia múltiple permite que una nueva clase derive de dos o más clases base. Por ejemplo, podemos crear un Omnívoro que herede tanto de Herbívoro como de Carnívoro, permitiéndole comer tanto carne como plantas. Aunque la implementación exacta no se presenta en el código, el concepto base es claro: la herencia múltiple puede resultar útil para definir clases que cumplan más de una función.

La herencia y especialización de clases en C++ permite una extensa reutilización de código, creando estructuras ricas y bien organizadas. Así podemos modelar de manera efectiva el comportamiento complejo del mundo real dentro de nuestros programas. ¡Continúa explorando las maravillas de la herencia y expande tus horizontes de programación!

Aportes 13

Preguntas 3

Ordenar por:

¿Quieres ver más aportes, preguntas y respuestas de la comunidad?

Willy Aguirre

hace 4 años

#include <iostream>
#include <string>

using namespace std;

class Animal {
    protected:
        static int numeroAnimales;
        string alimento;
    public:
        Animal();
        ~Animal();
        static int obtenerNumeroAnimales();
        string obtenerAlimento() {
            return alimento;
        }
        void comer() {
            cout << "Este animal está comiendo " << alimento << "... ñom ñom" << endl;
        }
};

int Animal::numeroAnimales = 0;

Animal::Animal() {
    cout << "Creando nuevo animal..." << endl;
    numeroAnimales += 1;
}

Animal::~Animal() {
    cout << "Borrando animal..." << endl;
    numeroAnimales -= 1;
}

int Animal::obtenerNumeroAnimales() {
    return numeroAnimales;
}

class Herviboro : public Animal {
    public:
        Herviboro() : Animal() {
            this->alimento = "plantas";
        }
        void pastar() {
            cout << "Este animal está pastando..." << endl;
        }
};

class Carnivoro : public Animal {
    public:
        Carnivoro() : Animal() {
            this->alimento = "carne";
        }
        void cazar() {
            cout << "Este animal está cazando..." << endl;
        }
};

int main() {
    Animal *a = new Animal();
    Herviboro *h = new Herviboro();
    Carnivoro *c = new Carnivoro();
    cout << "Numero de animales " << Animal::obtenerNumeroAnimales() << endl;
    a->comer();    
    h->pastar();
    c->cazar();
    delete a;
    cout << "Numero de animales " << Animal::obtenerNumeroAnimales() << endl;    
}

Maldonado Rosa

hace 3 años

Private: son aquellos que son visibles solo para las clases a las que pertenecen.
Protected: son aquellos que son visibles solo en las clases a las que pertenecen además de sus subclases

Miguel Diaz

hace 4 años

#include <iostream>
#include <string>

using namespace std;

class Animal{
private:
static int numero_animales;
string alimento;
public:
Animal();
~Animal();
static int obtenerNumeroAnimales();
string obtenerAlimento(){
return alimento;
}
void comer(){
cout<<"Este animal esta comiendo “<< alimento << " ñumñum”<<endl;

};

int Animal::numero_animales=0;

Animal::Animal(){
cout << “Creando nuevo animal…”<< endl;
numero_animales +=1;
}

Animal::~Animal(){
cout << “Borrando animal…”<< endl;
numero_animales -=1;
}

int Animal::obtenerNumeroAnimales(){
return numero_animales;
}

int main(){

Animal *a = new Animal();

cout<< "Numero de Animales: "<< Animal::obtenerNumeroAnimales()<< endl;

a->comer();

delete a;

cout<< "Numero de Animales: "<< Animal::obtenerNumeroAnimales()<< endl;

}

Uriel Barranco Robles

hace 3 años

Modificadores de Acceso en la Herencia

Cuando heredamos de otra clase, a la cual podemos llamar clase padre o superclase, también heredamos sus atributos, métodos, etc. a excepción de los que se encuentren con el modificador de acceso private. Los que se encuentren como public ó protected serán heredados a la clase hija.

Ahora cuando definimos la herencia lo hacemos por medio de declarar nuestra nueva clase, seguido de dos puntos ( : ), escribimos el modificador de acceso, tenemos 3 opciones (public, protected y private), y por último el nombre de la superclase.

class nombreSubClase : (public, protected o private) nombreSuperClase(){
	//Código
}

De acuerdo al modificador de acceso que indiquemos al definir la herencia, así será el modificador de acceso con el que se definirán en nuestra subclase.

Dejo una captura de pantalla de un libro de la editorial RedUsers que se llama “C++ Programación orientada a objetos”. Ha sido un buen complemento para entender los conceptos de este lenguaje de programación.

Ivan Daniel Oviedo Alvarado

hace 2 años

Saludos a todos,
Les comparto mi repo espero que sea de utilidad, he realizado una pequeña estructura de archivos, ya que considero que en producción es la forma más adecuada, por favor en caso de que tengan algún comentario estaría muy agradecido que me lo comenten.

Repo: https://github.com/ioviedodev/cpp_notes/tree/main/poo_example_1

Willy Aguirre

hace 4 años

la clase Animal

#include <iostream>
#include <string>

using namespace std;

class Animal {
    private:
        static int numeroAnimales;
        string alimento;
    public:
        Animal();
        ~Animal();
        static int obtenerNumeroAnimales();
        string obtenerAlimento() {
            return alimento;
        }
        void comer() {
            cout << "Este animal está comiendo " << alimento << "... ñom ñom" << endl;
        }
};

int Animal::numeroAnimales = 0;

Animal::Animal() {
    cout << "Creando nuevo animal..." << endl;
    numeroAnimales += 1;
}

Animal::~Animal() {
    cout << "Borrando animal..." << endl;
    numeroAnimales -= 1;
}

int Animal::obtenerNumeroAnimales() {
    return numeroAnimales;
}

int main() {
    Animal *a = new Animal();
    cout << "Numero de animales " << Animal::obtenerNumeroAnimales() << endl;
    a->comer();
    delete a;
    cout << "Numero de animales " << Animal::obtenerNumeroAnimales() << endl;
}

Jhon Sebastian Zuluaga Castañeda

hace 3 años

#include <iostream>
#include <string>

using namespace std;

class Animal {
    protected:
        static int numeroAnimales;
        string alimento;
    public:
        Animal();
        ~Animal();
        static int obtenerNumeroAnimales();
        string obtenerAlimento() {
            return alimento;
        }
        void comer() {
            cout << "Este animal está comiendo " << alimento << "... ñom ñom" << endl;
        }
};

int Animal::numeroAnimales = 0;

Animal::Animal() {
    cout << "Creando nuevo animal..." << endl;
    numeroAnimales += 1;
}

Animal::~Animal() {
    cout << "Borrando animal..." << endl;
    numeroAnimales -= 1;
}

int Animal::obtenerNumeroAnimales() {
    return numeroAnimales;
}

class Herviboro : public Animal {
    public:
        Herviboro() : Animal() {
            this->alimento = "plantas";
        }
        void pastar() {
            cout << "Este animal está pastando..." << endl;
        }
};

class Carnivoro : public Animal {
    public:
        Carnivoro() : Animal() {
            this->alimento = "carne";
        }
        void cazar() {
            cout << "Este animal está cazando..." << endl;
        }
};

int main() {
    Animal *a = new Animal();
    Herviboro *h = new Herviboro();
    Carnivoro *c = new Carnivoro();
    cout << "Numero de animales " << Animal::obtenerNumeroAnimales() << endl;
    a->comer();    
    h->pastar();
    c->cazar();
    delete a;
    cout << "Numero de animales " << Animal::obtenerNumeroAnimales() << endl;    
}

rolycf

hace 4 años

rolycf

hace 4 años

Farid HM

hace 4 años

#include <iostream>
#include <conio.h>
#include <stdlib.h>
#include <string>
#include <locale.h>

using namespace std;
class Mounstro {
protected:
	static int numeroMounstros;
	string alimento;
public:
	Mounstro();
	~Mounstro();
	static int obtenerNumeroMounstros();
	string obtenerAlimento() {
		return alimento;
	}
	void comer() {
		cout << "Este mounstro está comiendo " << alimento << " rico, rico " << endl;
	}
	
};

int Mounstro::numeroMounstros = 0;
Mounstro::Mounstro()
{
	cout << "Creando nuevo mounstro...." << endl;
	numeroMounstros += 1;
}
int Mounstro::obtenerNumeroMounstros()
{
	return numeroMounstros;
}
Mounstro::~Mounstro()
{
	cout << "borrando bicho...." << endl;
	numeroMounstros -= 1;
}
class Herviboro : public Mounstro{
public:
	Herviboro() : Mounstro() {
		this->alimento = "plantas";
}
	void pastar() {
		cout << "Este animal está pastando... " << endl;
	}
};

class Carnivoro : public Mounstro {
public :
	Carnivoro() : Mounstro() {
		this->alimento = "carne";
	}
	void cazar() {
		cout << "Este animal está cazando..." << endl;
	}
};



	int main() {
		setlocale(LC_ALL, "");

		Mounstro* m = new Mounstro();
		Herviboro* h = new Herviboro();
		Carnivoro* c = new Carnivoro();

		cout << "Numero de mounstros: " << Mounstro::obtenerNumeroMounstros() << endl;
		m->comer();
		h->pastar();
		c->cazar();
		delete m;
		cout << "Numero de mounstros: " << Mounstro::obtenerNumeroMounstros() << endl;
	getch();
};

Juan Carlos Nevárez

hace 2 meses

Les paso un repositorio en el que junte los códigos hechos en clase junto con notas hechas en formato markdown: <https://github.com/CubicNev/Cpp-POO>

Dani-Ideas

hace 2 años

este es mi codigo :

#include <iostream>
#include <string>

using namespace std;

//int Npc::number_elemets=0;

class Npc {
    private:
        int age;
        string name;
        static int number_elemets;
    public:
        int job = 0;
        Npc(string name_input,int age_input){
            this-> name=name_input;
            this-> age = age_input;
  //         number_elemets+=1;
        }
        ~Npc(){
            cout << name<<" fue eliminado";
        }
        void updateName(string NewName){
            this-> name;
        }
        void updateAge(int newAge){
            this-> age= newAge;
        }
        void interaction(){
            string ocupations[]={"Desempleado","Profesor","Ingeniero","Medico","Abogado","Programador","Arquitecto","Veterinario","Psicologo","Enfermero","Diseñador","Contador","Cocinero","Electricista","Periodista","Actor","Músico","Escritor","Policía","Bombero","Astrónomo"} ;
            if (age<18&&job==0)
                cout << "Actualmete soy estudiante"<<endl;
            else    
                cout << "Actualmete trabajo como "<< ocupations[job]<<endl;
            //delete this;
        }

        void Say_hello(){
            cout << "Hola mi nombre es "<<name<<endl;
            interaction();
        }
};

class User : public Npc{
    public:
    int lives;
    User(string name_input, int age_input, int input_lives): Npc(name_input,age_input){
        this-> lives=input_lives;
    }
    void attack(){
        cout<< "Ataque\n";
    }
};

int check_if_number(string intput){
    int verification= stoi(intput);
    if(verification>0&&verification<4)
        return verification;
    else 
        return 0;
}

int main (){
    Npc *carlos=new Npc ("Carlos de la O",42);
    /*
    carlos->name="Carlos de la O";
    carlos->age=42;
    */
    carlos->job=12;
    carlos->Say_hello();
    Npc *juan=new Npc("Carlos Pedocles Poncho",10);
    juan->Say_hello(); 
    User *flint=new User("Flint loco",28,10); 
    flint->attack();
}

sadsax x_x

hace 3 años

#include <iostream>
#include <string>

using namespace std;

class Animal {
    protected:
        static int numeroAnimales;
        string alimento;
    public:
        Animal(); //constructor
        ~Animal(); //destructor

        static int obtenerNumeroAnimales(); //metodo 
        
        string obtenerAlimento() { //metodo
            return alimento;
        }
        void comer() { //metodo
            this->alimento = "pechungona";
            cout << "Este animal esta comiendo " << alimento << "... yomi yomi" << endl;
        }
};

int Animal::numeroAnimales = 0;

Animal::Animal() {
    cout << "Creando nuevo animal..." << endl;
    numeroAnimales += 1;
}

Animal::~Animal() {
    cout << "Borrando animal..." << endl;
    numeroAnimales -= 1;
}

int Animal::obtenerNumeroAnimales() {
    return numeroAnimales;
}

class Herviboro : public Animal { //clase hija de clase Animal
    public:
        Herviboro() : Animal() {
            this->alimento = "baretica";
        }
        void pastar() {
            cout << "Este animal esta enrolando "<< this->alimento << endl;
        }
};

class Carnivoro : public Animal { //clase hija de clase Animal
    public:
        Carnivoro() : Animal() {
            this->alimento = "carne";
        }
        void cazar() {
            this->alimento = "a las bbys";
            cout << "Este animal esta cazando " << this->alimento << endl;
        }
};

int main() {
    Animal *a = new Animal();
    Herviboro *h = new Herviboro();
    Carnivoro *c = new Carnivoro();
    cout << "Numero de animales " << Animal::obtenerNumeroAnimales() << endl;
    a->comer();    
    h->pastar();
    c->cazar();
    delete a;
    cout << "Numero de animales " << Animal::obtenerNumeroAnimales() << endl;    
}