J'ai un exemple de moi essayant de créer un "chien" dérivé de la classe de base "animal", mais je souhaite créer des cas de classe d'animaux et utiliser ses membres (je suis assez nouveau au polymorphisme en C ++). Le résultat produit 2 lignes de "un animal est créé!" et 1 ligne de "un chien est créé!" Pendant que je m'attends à 1 ligne de chacun.
class Animal
{
private:
int numberOfLegs;
const char* name;
public:
int getNumberOfLegs();
const char* getName();
virtual void ToString()
{
std::cout << "This animal has " << this->getNumberOfLegs();
std::cout << "leg and its name is " << getName() << std::endl;
}
Animal(int, const char*);
~Animal();
};
int Animal::getNumberOfLegs()
{
return this->numberOfLegs;
}
const char* Animal::getName()
{
return this->name;
}
Animal::Animal(int legs, const char* name)
{
this->numberOfLegs = legs;
this->name = name;
std::cout << "An animal is created!" << std::endl;
}
Animal::~Animal()
{
std::cout << "An animal is destroyed!" << std::endl;
}
class Dog : public Animal
{
private:
const char* speech;
public:
void ToString()
{
std::cout << "This dog has " << this->getNumberOfLegs();
std::cout << " legs and its name is " << this->getName();
std::cout << " and it says " << this->speech << std::endl;
}
Dog(int, const char*, const char*);
~Dog();
};
Dog::Dog(int legs, const char* name, const char* speech) : Animal (legs, name)
{
this->speech = speech;
std::cout << "A dog is created!" << std::endl;
}
Dog::~Dog()
{
std::cout << "A dog is destroyed!" << std::endl;
}
int main()
{
Animal anAnimal(3, "Godzilla");
Dog myDoge(4, "CuteDoge", "woof");
char c;
std::cin.get(c);
}
}
3 Réponses :
Dans votre hiérarchie, le chien hérite de l'animal. Cela signifie que lorsqu'un chien est construit animal, son parent est construit en premier. C'est pourquoi, lorsque vous créez un chien, vous obtenez «l'animal est créé» et que «chien est créé».
Pour éviter d'autres problèmes, vous devez suivre la règle de 3: vous avez un destructeur non trivial, vous devez également également. Définissez le constructeur de copie et l'opérateur d'affectation. Sinon, vous aurez une mémoire double et / ou une mémoire libérée à double libération.
En outre, puisque vous pouvez avoir des enfants non triviaux à l'animal, vous devez rendre le destructeur virtuel. Sinon, sans un destructeur virtuel chez l'animal, le destructeur de chien ne sera jamais appelé.
comme chien code> est un animal code>, et dans votre constructeur, vous pouvez voir: std::cout << "An animal is created!" << std::endl;
// ...
std::cout << "A dog is created!" << std::endl;
CETTE LIGNE:
Dog::Dog(int legs, const char* name, const char* speech) : Animal (legs, name)
La règle 3: Vous avez un destructeur non trivial, vous avez donc besoin d'un constructeur de copie et d'un opérateur d'affectation. En outre, le destructeur dans un tel cas doit être virtuel