Appel de méthode de la classe dérivée de la classe de base de référence

class Material
{
public:
 void foo()
 {
  cout << "Class Material";
 }
};

class Unusual_Material : public Material
{
public:
 void foo()
 {
  cout << "Class Unusual_Material";
 }
};

int main()
{
 Material strange = Unusual_Material();
 strange.foo(); //outputs "Class Material" 

 return 0;
}

Je voudrais que cette de suite dans la "Classe Unusual_Material" affiché sur la console. Est-il un moyen que je peux accomplir cela? Dans mon programme j'ai une classe de matière à partir de laquelle d'autres plus spécifiques des matériaux sont dérivés. La méthode Matériel::foo() représente une méthode de Matériau qui est suffisant pour la plupart des matériaux, mais occationally, un autre foo() doit être défini pour un matériau avec des propriétés inhabituelles.

Tous les objets dans mon programme contient un champ de Matériau. Dans le cas où ils sont affectés à un matériau inhabituel, je voudrais la dérivée, inhabituel foo être appelé.

C'est probablement assez facile, voire impossible, mais je ne peux pas le comprendre de toute façon.

Grâce

Comme une note, un code comme Material strange = Unusual_Material(); peut entraîner l'objet de découpage problème: stackoverflow.com/questions/274626/...

OriginalL'auteur user487100 | 2010-11-17

  1. 20

    Ce que vous voulez, c'est le polymorphisme, et de l'activer pour une fonction, vous devez faire virtual:

    class Material 
{ 
public: 
    virtual void foo() //Note virtual keyword!
    { 
        cout << "Class Material"; 
    } 
}; 

class Unusual_Material : public Material 
{ 
public: 
    void foo() //Will override foo() in the base class
    { 
        cout << "Class Unusual_Material"; 
    } 
};

    Aussi, le polymorphisme ne fonctionne que pour les références et les pointeurs:

    int main()  
{  
    Unusual_Material unusualMaterial;
    Material& strange = unusualMaterial;
    strange.foo();  
    return 0; 
}

/* OR */

int main()  
{  
    Unusual_Material unusualMaterial;
    Material* strange = &unusualMaterial;
    strange->foo();  
    return 0; 
}

    Ce que vous avez dans votre extrait de code trancher le Unusual_Material de l'objet:

    int main() 
{ 
    //Unusual_Material object will be sliced!
    Material strange = Unusual_Material(); 
    strange.foo(); 
    return 0; 
}
    Ah! je vous remercie pour cette. Je suppose que j'ai oublié que le virtuel a été pendant plus de définir une classe abstraite. Merci pour la réponse rapide!
    Ce n'est pas grave, tant que vous vous rendez compte ce qui s'est passé. Je ne vous recommandons de récupérer une bonne C++ livre cependant, car il traite de ce sujet fondamental dans beaucoup plus de détails.
    Et je n'avais aucune idée sur le découpage. Je pensais que le programme serait juste de ne pas avoir accès aux pièces dérivées, mais je suppose que, lorsque vous n'utilisez pas un renvoi, ce qui rend beaucoup de sens. Merci pour l'ajout que peu à la fin pour mon édification.
    Il a à voir avec le fait que vous ne pouvez pas "digne" d'un objet d'une classe dérivée en un objet d'une classe de base, depuis la classe dérivée sera presque toujours plus de données des membres. Dans un sens, vous n'avez pas accès à la pièce dérivée, parce que ces pièces dérivées ont été coupés pour que le compilateur puisse affecter un objet de classe dérivée d'une classe de base de l'objet.
    Toutefois, des pointeurs et des références sont de la même taille, peu importe si elles sont des pointeurs vers une classe dérivée ou d'une classe de base, de sorte que vous n'obtenez pas de trancher des problèmes à l'aide des pointeurs et des références.

    OriginalL'auteur In silico

  2. 1

    Encore meilleure explication serait..

    class Base
{
public:
 void foo()     //make virtual void foo(),have derived method invoked
 {
  cout << "Class Base";
 }
};
class Derived: public Base
{
public:
 void foo()
 {
  cout << "Class Derived";
 }
};
int main()
{
 Base base1 = Derived ();
 Base1.foo(); //outputs "Class Base" 
           //Base object, calling base method

 Base *base2 = new Derived ();
 Base2->foo(); //outputs"Class Base",Again Base object calling base method

//But to have base object, calling Derived method, following are the ways
//Add virtual access modifier for base foo() method. Then do as below, to //have derived method being invoked.
//
//Base *base2 = new Derived ();
//Base2->foo();    //outputs "Class Derived" .

return 0;
}

    OriginalL'auteur Avinash Goud N J