Herencia en C++, llamando a Funciones heredadas

[LuisInfante]

Hola , ya llevo tiempo programando en C++ y aun no domino plenamente la herencia

por ejemplo

class vehiculo
{

insertarllave();
encender();

}

vehiculo::insertallave()
{

cout<<"meter llave";

}
vehiculo::encender()
{

cout<<"girar llave para encender";

}
class carro_standard:vehiculo
{

meterclutch();
insertallave();

}
carro_standard:metercluth()
{

cout<<"pisar clutch";

}
carro_standar:insertallave();
{

cout<<"insertar llave"
meterclutch();

}
main()
{

vehiculo_standard vh;
vh.encender();

}

okey perdonen el C++ simplificado

Mi idea es que no requiero un procedimiento para definir encender porque esta definido en la clase base, pero en el programa que estoy realizando , la funcion encender no es capaz de llamar a insertarllave() de la clase derivada, llalma a insertarllave() de la clase base

o sea el carro no prenderia porque no meti el clutch, solo inserte la llave

no estoy seguro si el mecanismo del polimorfismo, si llamando a funciones virtuales pueda lograr que una funcion de una clase base llame a una funcion de una clase derivada

actualmente redefino la funcion encender en la clase derivada , pero no me convence del todo porque repito codigo

[vangodp]

pues que raro a mi si me sale bien...

Código C++:

#include <iostream>
using namespace std;
class vehiculo {
        public:
        vehiculo(){}
        ~vehiculo(){}
            
            void insertarllave() { std::cout << "BASE: meter llave" << std::endl; }
            void encender()      { std::cout << "BASE: girar llave para encender" << std::endl; }
        
};
 
 
class carro_standard : public vehiculo {
        public:
        void insertarllave() {  std::cout << "HEREDADA: insertar llave" << std::endl; meterclutch();}
        void meterclutch()  {   std::cout << "HEREDAD:  pisar clutch" << std::endl;}
        
};
 
int main() {
 
    carro_standard vh;
    vh.insertallave();
    return 0;   
}
 

Resultado:
HEREDADA: insertar llave
HEREDAD: pisar clutch

No es esto lo que quieres?

[LuisInfante]

Gracias por la ayuda
algo parecido es lo que me planteas, aunque tu redefines por ejemplo el procedimiento insertarllave() , pero en mi ejemplo yo no redefino el procedimiento encender() porque supongo que ya existe en la clase heredada

De hecho me faltaron funciones en el procedimento encender() para que se comprendiera el ejemplo, en mi concepcion para encender debemos

Código C++:

encender()
{
       insertarllave();
       cout<<"girar llave";
}
 

cuando yo uso la funcion encender solo utilizo la funcion insertarllave de la clase base, pero la funcion insertallave() yo la redefini para que tambien estuviera la funcion meterclutch()

Código C++:

vehiculo::insertallave()
{ 
        cout<<"inserta llave"
}
 

en la redefinida yo agrego la funcion meterclutch en insertallave()

Código C++:

carro_standard::insertallave()
{ 
        cout<<"inserta llave";
        meterclutch();
}
 

pero no redefino la funcion encender

[vangodp]

Pues no se....
Lo veo chungo el tema.
No veo el motivo por el cual quieras acceder a una función de una clase derivada.Quizás esta función deba estar en la clase base también.
Pero si quieres acceder a ella una opción seria esta =D

Código C++:

#include <iostream>
using namespace std;
 
void foo();
 
class vehiculo {
        public:
        void insertarllave() {cout << "meter llave";}
        void encender(){                    
            cout << "girar llave para encender\n";
            foo();
        }               
};
 
class carro_standard:public vehiculo {
        public:
        carro_standard(){}
        ~carro_standard(){}     
        void meterclutch()  { cout << "pisar clutch"; }
        void insertallave() { cout << "insertar llave"; meterclutch(); }
        
};
 
//Funcion de acceso a la clase heredada =D
void foo(){
    carro_standard unCarro;
    unCarro.meterclutch();
}
 
main() {
    carro_standard vh;
    vh.encender();  
}
 

[LuisInfante]

gracias por la ayuda

si esta algo raro, tu ejemplo correria si no me equivoco otro carro, ya que define otro carro en la funcion, no el carro que yo pretendo correr

pero tal vez tengas razon y estoy pidiendole demasiado al mecanismo de herencia, actualmente yo redefino la funcion encender en la clase heredada y agrego la funcion sobrecargada que quiero llamar, tecnicamente se ven iguales la funcion encender en ambas clases solo que cuando yo corro encender del vehiculo que hereda , la funcion encender() utiliza las nuevas funciones sobrecargadas

pero tenia dudas si estaba desperdiciando los recursos que da C++ para crear clases, no estoy seguro si declarar virtuales las funciones puede ayudar a ahorrar codigo

yo nunca he usado funciones virtuales , ni tampoco la herencia multiple, me ha bastado con herencia y composicion de objetos

[vangodp]

-_-'

Código C++:

#include <iostream>
using namespace std;
class carro_standard;
void foo(carro_standard &C);
 
 
class vehiculo {
    
        public:
        void insertarllave() {cout << "meter llave";}
        void encender(carro_standard & unCarro){                    
            cout << "girar llave para encender\n";
            foo(unCarro);
        }               
};
 
 
class carro_standard:public vehiculo {
        public:
        carro_standard(){}
        ~carro_standard(){}     
        void meterclutch()  { cout << "pisar clutch"; }
        void insertallave() { cout << "insertar llave"; meterclutch(); }
        
};
//Funcion de acceso a la clase heredada =D
void foo( carro_standard & C ){ 
    C.meterclutch();
}
 
main() {
    carro_standard vh;
    
    
    vh.encender(vh);
    
}
 

[CalgaryCorpus]

Si quieres comportamiento modificado en la clase derivada, pero quieres que el metodo invocado reaccione de acuerdo al tipo de objeto, tienes que definir en la clase base el metodo (o los metodos) como virtuales.

Si tuvieras una funcion

Código C++:

void f( Vehiculo* pvehiculo ) {
     pvehiculo->metodo_virtual();
}
 

esta funcion trabajaria tanto con vehiculos como con derivados de este, y se invocaría siempre el metodo mas "cercano" (en el caso de los derivados, el metodo definido en esa particular clase).

El no definirlo virtual hará que la función mostrada siempre invoque el método de la clase base, y necesitarías otra(s) función(es)para invocar los derivados.

Entonces: Lo recomendable es que definas los métodos a redefinir como virtuales en la clase base.

[vangodp]

CalgaryCorpus Si! :D

¿Algo parecido a esto no?

Código C++:

#include <iostream>
using namespace std;
 
class vehiculo {   
        public:
        void insertarllave() {cout << "meter llave";}
        //necesita metodo virtual =(
        virtual void encender(){cout << "BASE!..Girar llave para encender\n\n";}              
};
class carro_standard:public vehiculo {
        public: 
        void meterclutch()  { cout << "Pisar clutch\n\n"; }
        void encender() { cout << "DERIBADA!..Girar llave para encender\n"; meterclutch(); }
};
 
 
int main() {
    carro_standard miCarro;
    //Recorte de objetos o "slicing"    
    vehiculo& pVehiculo = miCarro; //Si paso carro como puntero o referencia accedo a la clase derivada
    vehiculo objVeyculo = miCarro; //Si paso el obj accedo a la clase base.
    //Importante...fijese que le paso el objeto derivado De 2 formas distintas y obtengo 2 resultados
    //distintos segun quiera una cosa u otra, pero les paso a la clase "BASE" WTF!XD
    
    objVeyculo.encender();//Aqui comprobamos el objeto "miCarro" recortado que me da acceso a la clase base de "miCarro"
    pVehiculo.encender();//Aqui comprobamos la referencia, que me da como resultado la clase derivada de "miCarro"
    //Es un tema Bochornozo....Lea mucho sobre el antes de usar XDD   
    return 0;
}
 

Si le pasas un puntero/referencia o le pasas un objeto tienes dos funcionamientos distintos.
Muy interesante, estoy leyendo sobre eso. ^^
A ver si logro pillar el trankillo sobre el tema =D

[CalgaryCorpus]

Cuando haces esto:

Código C++:

vehiculo objVeyculo = miCarro;
 

estas haciendo una copia, definiendo un nuevo objeto. No hay duda, para el compilador, que cuando invocas metodos de ese objeto, seran de la clase base.

En cambio, en la asignacion de la referencia, actuaran los metodos virtuales.

[vangodp]

¡Gracias!
Los forillos son una maravilla, sobretodo los artistas que andan por ellos :)
Voy pillando el truco.
El tema es interesante, aquí me voy a dejar el pellejo jeje.
Después para mejorar aun mas... jeje. Los tal constructores virtuales.
wuoo que dolor de cabeza XD

[CalgaryCorpus]

Constructores virtuales? Creo que en C++ no existe un constructor en que sea necesario decir "virtual" y el que no hacerlo implique un comportamiento distinto.
Siempre se invoca el constructor mas cercano.

Distinto caso los destructores, que deberian ser siempre virtuales.

[vangodp]

Ya...es que no se puede según parece.
Es una jugada que hay que hacer. Algo como una copia del constructor pasando un puntero this y con esa copia es lo que dice los ejemplos que estoy mirando pfff
Aun no tengo ni idea >_<