Comment atteindre virtuel de la fonction de modèle” en C++

Après réflexion, j'ai reconnu ce que la classique multi-méthode exigence, c'est à dire une méthode qui distribue basé sur la runtime type de plus d'un paramètre. D'habitude fonctions virtuelles sont single dispatch en comparaison (et ils acheminent sur le type de this seulement).

Consulter les documents suivants:

• Andrei Alexandrescu a écrit (le sperme de bits pour le C++?) sur la mise en œuvre multi-méthodes utilisant des génériques dans "Modern C++ design"
  • Chapitre 11: "Multimethods" - il implémente base multi-méthodes, les rendant logarithmique (à l'aide d'commandé typelists), puis d'aller tout le chemin à la constante de temps multi-méthodes. Assez puissant !
• Un codeproject article qui semble avoir une telle mise en œuvre:
  • pas utiliser de type jette de toute nature (dynamique, statique, réinterpréter, const ou de style C)
  • pas utiliser de RTTI;
  • pas utiliser de préprocesseur;
  • forte sécurité de type;
  • compilation séparée;
  • de la constante de temps de multimethod exécution;
  • pas d'allocation dynamique de la mémoire (par le biais des nouvelles ou malloc) au cours de multimethod appel;
  • pas utiliser de non bibliothèques;
  • seulement des fonctionnalités C++ standard est utilisé.
• C++ Méthode Ouverte De Compilateur, Peter Pirkelbauer, Yuriy Solodkyy, et Bjarne Stroustrup
• Le Loki Bibliothèque a Un MultipleDispatcher
• Wikipédia a tout à fait une belle simple write-up avec des exemples sur la répartition Multiple en C++.

Ici est le "simple" approche à partir de l'article de wikipédia pour référence (le moins simple approche des échelles de mieux pour un plus grand nombre de types dérivés):

//Example using run time type comparison via dynamic_cast
struct Thing {
virtual void collideWith(Thing& other) = 0;
}
struct Asteroid : Thing {
void collideWith(Thing& other) {
//dynamic_cast to a pointer type returns NULL if the cast fails
//(dynamic_cast to a reference type would throw an exception on failure)
if (Asteroid* asteroid = dynamic_cast<Asteroid*>(&other)) {
//handle Asteroid-Asteroid collision
} else if (Spaceship* spaceship = dynamic_cast<Spaceship*>(&other)) {
//handle Asteroid-Spaceship collision
} else {
//default collision handling here
}
}
}
struct Spaceship : Thing {
void collideWith(Thing& other) {
if (Asteroid* asteroid = dynamic_cast<Asteroid*>(&other)) {
//handle Spaceship-Asteroid collision
} else if (Spaceship* spaceship = dynamic_cast<Spaceship*>(&other)) {
//handle Spaceship-Spaceship collision
} else {
//default collision handling here
}
}
}

Je pense que le modèle visiteur peut être une solution.

Mise à JOUR

J'ai fini mon exemple:

#include <iostream>
#include <vector>
#include <boost/shared_ptr.hpp>
class Animal;
class Wolf;
class Fish;
class Visitor
{
public:
virtual void visit(const Animal& p_animal) const = 0;
virtual void visit(const Wolf& p_animal) const = 0;
virtual void visit(const Fish& p_animal) const = 0;
};
template<class AMOUNT>
class AmountVisitor : public Visitor
{
public:
AmountVisitor(AMOUNT p_amount) : m_amount(p_amount) {}
virtual void visit(const Animal& p_animal) const
{
std::cout << "I eat like a generic Animal." << std::endl;
}
virtual void visit(const Wolf& p_animal) const
{
std::cout << "I eat like a wolf!" << std::endl;
}
virtual void visit(const Fish& p_animal) const
{
std::cout << "I eat like a fish!" << std::endl;
}
AMOUNT m_amount;
};
class Animal {
public:
virtual void Accept(const Visitor& p_visitor) const
{
p_visitor.visit(*this);
}
virtual ~Animal() {
}
};
class Wolf : public Animal {
public:
virtual void Accept(const Visitor& p_visitor) const
{
p_visitor.visit(*this);
}
};
class Fish : public Animal {
public:
virtual void Accept(const Visitor& p_visitor) const
{
p_visitor.visit(*this);
}
};
int main()
{
typedef boost::shared_ptr<Animal> TAnimal;
std::vector<TAnimal> animals;
animals.push_back(TAnimal(new Animal()));
animals.push_back(TAnimal(new Wolf()));
animals.push_back(TAnimal(new Fish()));
AmountVisitor<int> amount(10);
for (std::vector<TAnimal>::const_iterator it = animals.begin(); it != animals.end(); ++it) {
(*it)->Accept(amount);
}
return 0;
}

cette affiche:

I eat like a generic Animal.
I eat like a wolf!
I eat like a fish!

Virtuel fonction de modèle n'est pas autorisé. Cependant, vous pouvez utiliser l'un OU l'autre ici.

Vous pourriez faire une interface à l'aide de méthodes virtuelles et de mettre en œuvre vos animaux divers en termes d'avoir une alimentation interface. (c'est à dire PIMPL)

Moins intuitive de l'homme serait d'avoir un non-membre non-ami modèle de fonction comme une fonction libre qui pourrait prendre basées sur des modèles de const référence à tout animal et de les faire manger en conséquence.

Pour l'enregistrement, vous n'avez pas besoin de modèles ici. Virtuelle Pure méthode abstraite sur la classe de base est assez à la force et à l'interface où tous les animaux doivent manger et de définir la façon dont ils le font avec un remplacement, en fournissant régulièrement virtuel suffirait de dire que tous les animaux peuvent manger, mais si ils n'ont pas une manière spécifique, il peut utiliser cette méthode par défaut.

J'ai copié ton code et l'a modifié, de sorte que maintenant, il doit travailler exactement comme vous le souhaitez:

        #include <iostream>
#include <vector>
//defined new enum type
enum AnimalEnum
{
animal,
wolf,
fish,
goldfish,
other
};
//forward declarations
class Wolf;
class Fish;
class GoldFish;
class OtherAnimal;
class Animal {
private:
AnimalEnum who_really_am_I;
void* animal_ptr;
public:
//declared new constructors overloads for each type of animal
Animal(const Animal&);
Animal(const Wolf&);
Animal(const Fish&);
Animal(const GoldFish&);
Animal(const OtherAnimal&);
template< class AMOUNT >
/*removed the virtual keyword*/ void eat( AMOUNT amount ) const { 
switch (this->who_really_am_I)
{
case AnimalEnum::other: //You defined OtherAnimal so that it doesn't override the eat action, so it will uses it's Animal's eat
case AnimalEnum::animal: std::cout << "I eat like a generic Animal." << std::endl; break;
case AnimalEnum::wolf: ((Wolf*)this->animal_ptr)->eat(amount); break;
case AnimalEnum::fish: ((Fish*)this->animal_ptr)->eat(amount); break;
case AnimalEnum::goldfish: ((GoldFish*)this->animal_ptr)->eat(amount) break;
}
}
void DeleteMemory() { delete this->animal_ptr; }
virtual ~Animal() { 
//there you can choose if whether or not to delete "animal_ptr" here if you want or not
}
};
class Wolf : public Animal {
public:
template< class AMOUNT >
void eat( AMOUNT amount) const { 
std::cout << "I eat like a wolf!" << std::endl; 
}
virtual ~Wolf() { 
}
};
class Fish : public Animal {
public:
template< class AMOUNT >
void eat( AMOUNT amount) const { 
std::cout << "I eat like a fish!" << std::endl; 
}
virtual ~Fish() { 
}
};
class GoldFish : public Fish {
public:
template< class AMOUNT >
void eat( AMOUNT amount) const { 
std::cout << "I eat like a goldfish!" << std::endl; 
}
virtual ~GoldFish() { 
}
};
class OtherAnimal : public Animal {
//OtherAnimal constructors must be defined here as Animal's constructors
OtherAnimal(const Animal& a) : Animal(a) {}
OtherAnimal(const Wolf& w) : Animal(w) {}
OtherAnimal(const Fish& f) : Animal(f) {}
OtherAnimal(const GoldFish& g) : Animal(g) {}
OtherAnimal(const OtherAnimal& o) : Animal(o) {}
virtual ~OtherAnimal() { 
}
};
//OtherAnimal will be useful only if it has it's own actions and members, because if not, typedef Animal OtherAnimal or using OtherAnimal = Animal can be used, and it can be removed from above declarations and below definitions
//Here are the definitions of Animal constructors that were declared above/before:    
Animal::Animal(const Animal& a) : who_really_am_I(AnimalEnum::animal), animal_ptr(nullptr) {}
Animal::Animal(const Wolf& w) : who_really_am_I(AnimalEnum::wolf), animal_ptr(new Wolf(w)) {}
Animal::Animal(const Fish& f) : who_really_am_I(AnimalEnum::fish), animal_ptr(new Fish(f)) {}
Animal::Animal(const GoldFish& g) : who_really_am_I(AnimalEnum::goldfish), animal_ptr(new GoldFish(g)) {}
Animal::Animal(const OtherAnimal& o) :
who_really_am_I(AnimalEnum::other), animal_ptr(new OtherAnimal(o)) {}
int main() {
std::vector<Animal> animals;
animals.push_back(Animal());
animals.push_back(Wolf()); //Wolf is converted to Animal via constructor
animals.push_back(Fish()); //Fish is converted to Animal via constructor
animals.push_back(GoldFish()); //GoldFish is converted to Animal via constructor
animals.push_back(OtherAnimal()); //OtherAnimal is converted to Animal via constructor
for (std::vector<Animal>::const_iterator it = animals.begin(); it != animals.end(); ++it) {
it->eat(); //this is Animal's eat that invokes other animals eat
//delete *it; Now it should be:
it->DeleteMemory();
}
animals.clear(); //All animals have been killed, and we don't want full vector of dead animals.
return 0;
}

Je ne travaille pas avec des modèles, mais je pense que:

(1) Vous ne pouvez pas utiliser des modèles à l'intérieur d'une classe, les modèles sont plus comme des types ou des variables globales.

(2) En O. O. P., le même problème que vous, et que vous essayez de résoudre à l'aide de modèles, peut être résolu par l'utilisation de l'héritage.

Classes fonctionnent comme des modèles, vous pouvez ajouter de nouvelles choses, ou de remplacer les choses de classes avec des pointeurs, pointeurs vers des objets (A. K. A. "références") et en remplaçant les fonctions virtuelles.

#include <iostream>
struct Animal {
virtual void eat(int amount ) {
std::cout << "I eat like a generic Animal." << std::endl;
}
virtual ~Animal() { }
};
#if 0
//example 1
struct Wolf : Animal {
virtual void eat(int amount) {
std::cout << "I eat like a wolf!" << std::endl;
}
};
struct Fish : Animal {
virtual void eat(int amount) {
std::cout << "I eat like a fish!" << std::endl;
}
};
#else
//example 2
struct AnimalFood {
virtual int readAmount() { return 5; }
virtual void showName() {
std::cout << "I'm generic animal food" << std::endl;
}
};
struct PredatorFood : AnimalFood {
virtual int readAmount() { return 500; }
virtual void showName() {
std::cout << "I'm food for a predator" << std::endl;
}
};
struct Fish : Animal {
virtual void eat(AnimalFood* aFood) {
if (aFood->readAmount() < 50) {
std::cout << "OK food, vitamines: " << aFood->readAmount() << std::endl;
} else {
std::cout << "too much food, vitamines: " << aFood->readAmount() << std::endl;
}
}
};
struct Shark : Fish {
virtual void eat(AnimalFood* aFood) {
if (aFood->readAmount() < 250) {
std::cout << "too litle food for a shark, Im very hungry, vitamines: " << aFood->readAmount() << std::endl;
} else {
std::cout << "OK, vitamines: " << aFood->readAmount() << std::endl;
}
}
};
struct Wolf : Fish {
virtual void eat(AnimalFood* aFood) {
if (aFood->readAmount() < 150) {
std::cout << "too litle food for a wolf, Im very hungry, vitamines: " << aFood->readAmount() << std::endl;
} else {
std::cout << "OK, vitamines: " << aFood->readAmount() << std::endl;
}
}
};
#endif
int main() {
//find animals
Wolf* loneWolf = new Wolf();
Fish* goldenFish = new Fish();
Shark* sharky = new Shark();
//prepare food
AnimalFood* genericFood = new AnimalFood();
PredatorFood* bigAnimalFood = new PredatorFood();
//give food to animals
loneWolf->eat(genericFood);
loneWolf->eat(bigAnimalFood);
goldenFish->eat(genericFood);
goldenFish->eat(bigAnimalFood);
sharky->eat(genericFood);
sharky->eat(bigAnimalFood);
delete bigAnimalFood;
delete genericFood;
delete sharky;
delete goldenFish;
delete loneWolf;
}

Acclamations.