如何在C++中实现"virtual template function"

不允许使用虚拟模板功能。但是，您可以在此处使用一个或另一个。

你可以使用虚拟方法制作一个界面，并在吃的界面上实现你的各种动物。(即PIMPL(

不太人性化的直觉是将非成员非朋友模板函数作为一个自由函数，它可以将模板化的常量引用到任何动物身上，并使它们相应地进食。

为了记录在案，您不需要此处的模板。基类上的纯虚拟抽象方法足以强制和接口所有动物必须吃的地方，并通过覆盖来定义它们是如何吃的，提供一个常规的虚拟方法就足以说明所有动物都可以吃，但如果它们没有特定的方式，则可以使用此默认方式。

您可以创建一个具有虚拟函数的模板类，并在派生类中实现函数，而无需使用模板，方法如下：

a.h:
template <class T>
class A
{
public:
    A() { qDebug() << "a"; }
    virtual A* Func(T _template) { return new A;}
};

b.h:
class B : public A<int>
{
public:
    B();
    virtual A* Func(int _template) { return new B;}
};

and the function CTOR and call 
  A<int>* a1=new B;
    int x=1;
    a1->Func(x);

不幸的是，我还没有找到一种方法来创建一个带有模板参数的虚拟函数，而不在dervied类上声明该类为模板和它的模板类型

        #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;
        }

在您的场景中，您正试图将编译时多态性与运行时多态性混合在一起，但这不能在这个"方向"上完成。

重要的是，您的AMOUNT模板参数表示要实现的类型的预期接口，该接口基于eat的每个实现使用的所有操作的并集。如果你在哪里创建一个抽象类型，声明这些操作中的每一个，使它们在需要的地方成为虚拟的，那么你可以用不同的类型(从你的AMOUNT接口派生的(调用eat。它的行为会如预期的那样。

我不使用模板，但我认为：

(1( 不能在类中使用模板，模板更像是全局类型或全局变量。

(2( 在O.O.p.中，您提出的问题，以及您试图通过使用模板来解决的问题，都可以通过使用继承来解决。

类的工作原理类似于模板，您可以通过添加新的东西来扩展，或者用指针、指向对象的指针(简称"引用"(和重写虚拟函数来替换类的东西。

#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;
}

干杯。