Tipos de acceso en la herencia de clases en programación

Clase 35 de 47 • Curso Práctico de C++

Como vimos en clase, herencia es la capacidad que tienen algunas clases (clase derivada) de heredar miembros y funciones de otras clases padre (clase base) y así crear jerarquías en nuestro programa. Una parte importante en la herencia es el tipo de acceso que se tiene a la información y miembros de la clase, estos son los siguientes:

Public: Los datos y funciones en esta área pueden ser accedidos por quien sea, al heredar de otra clase con sus datos se mantienen como públicos. Private: Ahora, los datos y funciones en esta área solo pueden ser accedidos por la clase y no por otros. Usando apuntadores uno puede saltarse esta regla pero no es recomendado. Protected: Funciona igual que private, la diferencia es que las clases derivadas pueden acceder a los datos miembro de la clase base que heredan cuando en private esto no es posible.

Elena Nuñez Malledo

student•

Buenas,

Dejo este esquema resumen de Herencia, y para ayudar a entender un poco temas como public, private o protected.

Ricardo Rito Anguiano

student•

Tengo una duda ¿Por que no tapaste atributos y métodos en la parte del private?

James Kristof Ubiarco Rodriguez

student•

@RicardoRA20 Porque dentro de la misma clase se pueden usar esos datos, como se ve en la clase de encapsulación

Carlos Abel Tarazona Aranda

student•

Dragon Ball :D

`#include <iostream>
using namespace std;

class SuperSayayin
{

protected:

    string name;
    int life, power;

public:

    SuperSayayin(string iName, int iLife, int iPower)
    {
        name = iName;
        life = iLife;
        power = iPower;
    }

    void Attack()
    {
        cout<<name<< ", Kame Hame HaaaA!! con: " <<power<< " de poder."<<endl;
    }
};

class Sayayin : public SuperSayayin
{
    public:

    Sayayin(string iName, int iLife, int iPower) : SuperSayayin(iName, iLife, iPower)
    {
        name = iName;
        life = iLife;
        power = iPower - 20;
    }
};

int main()
{
    SuperSayayin Goku("Son Goku", 100, 100);
    Sayayin Gohan("Son Gohan", 100, 100);

    cout<< "Dragon Ball" <<endl<<endl;
    Goku.Attack();
    Gohan.Attack();

    return 0;
}

Resultado :D

José Manuel Córdoba

student•

Gran ejemplo.

Carlos Abel Tarazona Aranda

student•

Gracias! ñ.ñ

Carlos Nassif Trejo Garcia

student•

Cambiando el programa seria asi:

#include &lt;iostream&gt;

using namespace std;

class Wizard {
protected:
    int mana, hp, power;

public:
    Wizard(int _mana, int _hp, int _power) {
        mana = _mana;
        hp = _hp;
        power = _power;
    }

    void spell() {
        cout &lt;&lt; &quot;fireworks!! &quot; &lt;&lt; power &lt;&lt; endl;
    }
};


class IceWizard : public Wizard {
public:
    IceWizard(int _mana, int _hp, int _power):
        Wizard(_mana, _hp, _power) {
            mana = _mana;
            hp = _hp;
            power = _power + 10;
    }
};

int main() {

    Wizard gandalf( 100, 10, 20 );
    gandalf.spell();

    IceWizard sauroMan( 100, 10, 20 );
    sauroMan.spell();

    return 0;
}

Juan Manuel Otero Rey

student•

Genial, pero la real pregunta es entonces porqueusar protected o private ? no nos interesa que todas las clases derivadas tengan acceso a todas las caracteristicas de una clase padre? abrazo crecks

Luis Javier Jaramillo García

student•

#include <iostream>

using namespace std;

class Mago{
private:
  //int mana, vida, poder; Aquí las clases heredadas no pueden acceder a los datos.
protected:
  int magia, vida, poder;
public:
  Mago(int iMagia, int iVida, int iPoder){
    magia = iMagia;
    vida = iVida;
    poder = iPoder;
  }
  void hechizo(){
    cout << "Lanzallamas" << poder << endl;
  }
};

class MagoHelado : public Mago{
public:
  MagoHelado(int iMagia, int iVida, int iPoder) : Mago(iMagia, iVida, iPoder){
    magia = iMagia;
    vida = iVida;
    poder = iPoder + 10;
  }
};

int main(){
  Mago Dumbledore(60, 30, 30);
  MagoHelado Ioga(60, 30, 30);
  Dumbledore.hechizo();
  Ioga.hechizo();
  return 0;
}

Reinaldo Mendoza

student•

Que buena la aclaración de protected

Juan Henao

student•

<code>
#include <iostream>

using namespace std;

class Vikingo
{
    protected:
        string name;
        int HP, Power;

    public:
        Vikingo(string iName, int iHP, int iPower)
        {
            name = iName;
            HP = iHP;
            Power = iPower;
        }
void Attack()
{
    cout << name <<" Ataca con la fuerza de " << Power << " Hombres"<< endl;
}
};

class ReyVikingo : public Vikingo
{
    public:

    ReyVikingo(string iName, int iHP, int iPower) : Vikingo(iName, iHP, iPower)
    {
        name = iName;
        HP = iHP + 100;
        Power = iPower + 20;
    }
};
int main()
{
    Vikingo Bjorn("Bjorn", 2600, 120);
    ReyVikingo Ragnar("Ragnar", 2500, 100);
    Bjorn.Attack();
    Ragnar.Attack();
    return 0;
}

Juan Camilo De Los Rios

student•

#include <iostream>

using namespace std;

class Mage
{

    public:

        Mage(int imana, int ihp, int ipower)
        {
            mana = imana;
            hp = ihp;
            power = ipower;
        }

        void spell()
        {
            cout<<"mage things blah blah blah xd - "<< power << endl;
        }

    protected:

        int mana, hp, power;

    private:


};

class iceMage : public Mage //Hereda de mago
{
    public:
        iceMage(int imana, int ihp, int ipower) : Mage(imana, ihp, ipower) //El constructor hereda de la clase padre tambien
        {
            mana = imana;
            hp = ihp;
            power = 10+ipower;
        }

    //Las clases no heredan atributos ni metodos privados
};

int main()
{

    Mage mine(100,10,20);
    mine.spell();

    iceMage elXD(100,10,20);
    elXD.spell();

    return 0;
}

Kevin Gerardo Mendez Argueta

student•

Ya aqui quede claro en base a mi comentario en la seccion anterior, pero aun asi creo que el maestro se enredo mucho pasando los atributos de privados a publicos. Como recomendacion o sugerencia, mejor los hubiera pasado a protegidos y de un solo hubiera explicado el tema para que esta seccion del curso no existiera.

Jose Antonio Rojas Ollarves

student•

Excelente explicacion muy concreta :D

Wilson Erik Ramírez Franco

student•

Casi no veo la diferencia de hacer otra clase, en el ejemplo anterior en la clase IceMage casi que copiamos todo lo que habia en la clase padre, todavía no me queda claro.

max marquez

student•

La utilidad general es agregar nuevas características.. en el ejemplo anterior el mago solo podía hacer spell , pero si quisiéramos una nueva clase de mago que ademas de spell también pueda hacer invocaciones, solo bastaría con heredar a mago y adicional mente añadir la habilidad invocación, algo tal que así:

invocation(String invocationType ) {
cout <<" haz invocado a " << invocationType << endl; }

Nota: posiblemente el ejemplo dado en case no exista tanta diferencia, pero hay muchos casos en los que una mínima diferencia es lo que necesitamos para cada nuevo objeto

Wilson Erik Ramírez Franco

student•

Muchas gracias maxmarqueza!

Jimmy Asdrubal Canales Zelaya

student•

pues aquí hice algo,no implementa el protected como tal, sin embargo hace uso de el polimorfismo de POO

#include <iostream>

#include <string>

using namespace std;

class Fighter

{

public:

string name;

int hp, power;

// constructor

Fighter(string iName, int iHp, int iPower)

{

name = iName;

hp = iHp;

power = iPower;

}

// functions

void attack()

{

cout << endl << name << " uso Spear\n"

<<"Daño: "<< power << endl;

}

void showStats()

{

cout<<"\n==="<<name<<"==="<<endl;

cout<<"HP: "<<hp<<endl;

cout<<"Power: "<<power<<endl;

}

};

class Samurai : public Fighter

{

public:

Samurai(string iName, int iHp, int iPower) : Fighter(iName, iHp, iPower + 50)

{

}

void attack()

{

cout << endl << name << " uso Katana Slash\n"

<<"Daño: "<< power << endl;

}

};

class Ninja : public Fighter

{

public:

Ninja(string iName, int iHp, int iPower) : Fighter(iName, iHp, iPower + 30)

{

}

void attack()

{

cout << endl<< name << " uso Shuriken\n"

<<"Daño: "<< power << endl;

}

};

class Knight : public Fighter

{

public:

Knight(string iName, int iHp, int iPower) : Fighter(iName, iHp, iPower + 70)

{

}

void attack()

{

cout << endl << name << " uso Sword Strike\n"

<<"Daño: "<< power << endl;

}

};

int main()

{

Fighter p1("Scorpion", 80, 20);

Samurai p2("Musashi", 55, 60);

Ninja p3("Ryu", 60, 40);

Knight p4("Arthur", 100, 80);

p1.attack();

p2.attack();

p3.attack();

p4.attack();

p1.showStats();

p2.showStats();

p3.showStats();

p4.showStats();

return 0;

}

Oscar Jaramillo

student•

Gracias

Diego Lozano Paz

student•

Buen resumen!

Angel Gabriel Martinez Gutiérrez

student•

Ahora entiendo mejor

Germán Rojas

student•

Gracias por la explicación, queda mucho más claro con este texto :D

Agustin Isaias Salinas Quinteros

student•

muchas gracias

Rafael Arteaga

student•

Quedo muy entendido este texto :D

GERARDO EMMANUEL ALONSO CELIS

student•

Osea que cada cada creación de un hijo va a tener que ir acompañada de su propio acceso privado o de otra forma acceder al padre mediante el protected?

oscar adrian hernandez vazquez

student•

bien gracias por la explicación.

`#include <iostream>
using namespace std;

class SuperSayayin
{

protected:

    string name;
    int life, power;

public:

    SuperSayayin(string iName, int iLife, int iPower)
    {
        name = iName;
        life = iLife;
        power = iPower;
    }

    void Attack()
    {
        cout<<name<< ", Kame Hame HaaaA!! con: " <<power<< " de poder."<<endl;
    }
};

class Sayayin : public SuperSayayin
{
    public:

    Sayayin(string iName, int iLife, int iPower) : SuperSayayin(iName, iLife, iPower)
    {
        name = iName;
        life = iLife;
        power = iPower - 20;
    }
};

int main()
{
    SuperSayayin Goku("Son Goku", 100, 100);
    Sayayin Gohan("Son Gohan", 100, 100);

    cout<< "Dragon Ball" <<endl<<endl;
    Goku.Attack();
    Gohan.Attack();

    return 0;
}

#include &lt;iostream&gt;

using namespace std;

class Wizard {
protected:
    int mana, hp, power;

public:
    Wizard(int _mana, int _hp, int _power) {
        mana = _mana;
        hp = _hp;
        power = _power;
    }

    void spell() {
        cout &lt;&lt; &quot;fireworks!! &quot; &lt;&lt; power &lt;&lt; endl;
    }
};


class IceWizard : public Wizard {
public:
    IceWizard(int _mana, int _hp, int _power):
        Wizard(_mana, _hp, _power) {
            mana = _mana;
            hp = _hp;
            power = _power + 10;
    }
};

int main() {

    Wizard gandalf( 100, 10, 20 );
    gandalf.spell();

    IceWizard sauroMan( 100, 10, 20 );
    sauroMan.spell();

    return 0;
}

#include <iostream>

using namespace std;

class Mago{
private:
  //int mana, vida, poder; Aquí las clases heredadas no pueden acceder a los datos.
protected:
  int magia, vida, poder;
public:
  Mago(int iMagia, int iVida, int iPoder){
    magia = iMagia;
    vida = iVida;
    poder = iPoder;
  }
  void hechizo(){
    cout << "Lanzallamas" << poder << endl;
  }
};

class MagoHelado : public Mago{
public:
  MagoHelado(int iMagia, int iVida, int iPoder) : Mago(iMagia, iVida, iPoder){
    magia = iMagia;
    vida = iVida;
    poder = iPoder + 10;
  }
};

int main(){
  Mago Dumbledore(60, 30, 30);
  MagoHelado Ioga(60, 30, 30);
  Dumbledore.hechizo();
  Ioga.hechizo();
  return 0;
}

<code>
#include <iostream>

using namespace std;

class Vikingo
{
    protected:
        string name;
        int HP, Power;

    public:
        Vikingo(string iName, int iHP, int iPower)
        {
            name = iName;
            HP = iHP;
            Power = iPower;
        }
void Attack()
{
    cout << name <<" Ataca con la fuerza de " << Power << " Hombres"<< endl;
}
};

class ReyVikingo : public Vikingo
{
    public:

    ReyVikingo(string iName, int iHP, int iPower) : Vikingo(iName, iHP, iPower)
    {
        name = iName;
        HP = iHP + 100;
        Power = iPower + 20;
    }
};
int main()
{
    Vikingo Bjorn("Bjorn", 2600, 120);
    ReyVikingo Ragnar("Ragnar", 2500, 100);
    Bjorn.Attack();
    Ragnar.Attack();
    return 0;
}

#include <iostream>

using namespace std;

class Mage
{

    public:

        Mage(int imana, int ihp, int ipower)
        {
            mana = imana;
            hp = ihp;
            power = ipower;
        }

        void spell()
        {
            cout<<"mage things blah blah blah xd - "<< power << endl;
        }

    protected:

        int mana, hp, power;

    private:


};

class iceMage : public Mage //Hereda de mago
{
    public:
        iceMage(int imana, int ihp, int ipower) : Mage(imana, ihp, ipower) //El constructor hereda de la clase padre tambien
        {
            mana = imana;
            hp = ihp;
            power = 10+ipower;
        }

    //Las clases no heredan atributos ni metodos privados
};

int main()
{

    Mage mine(100,10,20);
    mine.spell();

    iceMage elXD(100,10,20);
    elXD.spell();

    return 0;
}

Tipos de acceso en la herencia de clases en programación

Introducción a C++

Programación de Videojuegos con C++ desde Cero

Programación en C++: Fundamentos y Aplicaciones Prácticas

Conceptos Generales de C++

Historia y uso del compilador GCC en programación

Preparando el entorno de trabajo

Instalación de Code::Blocks en Windows paso a paso

Instalación de CodeBlocks en Mac paso a paso

Creación de un Proyecto de Consola en C++ Paso a Paso

Uso de Librerías y Entrada/Salida en C++

Manejo de memoria

Memoria y Tipos de Datos en Computadoras y Programación

Variables y tipos de datos en programación básica

Operadores Aritméticos y Lógicos en Programación

Uso de Apuntadores para Manipulación de Memoria en Programación

Cálculo del Área de Círculo y Esfera con Variables

Entrada de datos y funciones

Entrada y manejo de datos en programas C++

Operadores Relacionales y Condicionales en Programación

Condicionales y estructuras de control en programación

Funciones y Encapsulamiento en Programación

Funciones en Programación: Creación y Uso Eficiente

Creación de aventuras interactivas con C++ y decisiones de usuario

Loops y arreglos

Arreglos: Conceptos Básicos y Manipulación en Programación

Estructuras de Control: Bucles en Programación

Contadores y Bucles en Programación: While, Do-While y For

Arreglos Unidimensionales y Bidimensionales en Programación

Dibujar Mapas y Personajes en Juegos con Arreglos en C++

Movimiento de Personajes en Juegos con Python

Programación de Mapas Bidimensionales en Videojuegos

Movimiento de Personajes en Cuatro Direcciones con CIN

Lectura de Archivos

Lectura y escritura de archivos en C++ con fstream

Lectura y Escritura de Archivos en Programación

Posicionamiento del Jugador en el Mapa de Juego

Programación Orientada a Objetos

Programación Orientada a Objetos: Conceptos y Beneficios

Programación Orientada a Objetos: Clases e Instancias en Java

Encapsulación de Datos en Programación Orientada a Objetos

Abstracción en Programación Orientada a Objetos

Herencia en Programación Orientada a Objetos: Clases y Constructores

Tipos de acceso en la herencia de clases en programación

Polimorfismo en C++: Teoría y Práctica

Finalizando nuestro proyecto

Programación de un Juego de Laberinto en C++

Controles básicos de movimiento en videojuegos con programación en C++

Creación de Clases para Mapas en Juegos de Programación

Conexión de Jugador y Coordenadas en Mapas de Videojuegos

Carga y Lectura de Archivos para Mapas en Juegos

Colisiones y Movimiento en Juegos 2D con C++

Colisiones y restricciones de movimiento en mapas de juegos

Colisiones y Portadas en Videojuegos: Implementación en C++

Creación de Juegos de Aventuras en C++: Laberintos y Cofres del Tesoro

Programación Orientada a Objetos en Videojuegos Básicos

Creación de Enemigos y Laberintos en C++ Avanzado