No tienes acceso a esta clase

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

Herencia en C++: Crear Clases de Animales Especializadas

13/16
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?

#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;    
}

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

#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;

}

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.

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

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;
}
#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;    
}

j

j

#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();
};
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>

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();
}
#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;    
}