C++多态克隆模板类。不能使用克隆的对象作为参数在功能

Question

我有一个模板类Specie< T>派生自基类Animal。我创建了一个指向Animal的指针矢量，以便将不同类型的对象Specie<T>存储在同一个矢量中。 T可以是狗，猫等......

现在我想在模板函数中使用vector的某些元素作为参数。我为不同的模板参数T编写了函数的不同特化，因此每个Specie<T>的行为都不相同。为了从矢量中获得正确类型的每个对象，我使用了多态克隆。它运作良好，我得到正确类型的对象Specie<T>（请参阅下面的非常简短的测试）。但是，当我想使用矢量的元素作为模板函数的参数时，它不起作用。

// Base class 
class Animal{ 

public: 
    virtual ~Animal() {} 

    virtual Animal *clone() = 0; 
    virtual void action() = 0; 

}; 


// Specific types of animals. Forward declaration 
class Dog; 
class Cat; 



// Templated derived class Specie 
template <class T> 
class Specie : public Animal{ 

public: 
    Specie<T> *clone(); 

    void action(); 

}; 





template <class T> 
Specie<T> * Specie<T>::clone() { 

    std::cout << "Cloning a Specie<T>" << std::endl; 
    return new Specie<T>(*this); 

} 



// Specialization of templated function action() for Dog 
template <> 
void Specie<Dog>::action(){ 

    std::cout << "Wouaf !" << std::endl; 

} 


// Specialization of templated function action() for Cat 
template <> 
void Specie<Cat>::action(){ 

    std::cout << "Miaouuu !" << std::endl; 

} 




class Interaction{ 

public: 

    template <class T1> 
    static void DoSomething(Specie<T1>); 

}; 



// Specialization of templated function DoSomething() for Dog 
template <> 
void Interaction::DoSomething(Specie<Dog> obj){ 

std::cout << "Interact with Dog !" << std::endl; 

} 


// Specialization of templated function DoSomething() for Cat 
template <> 
void Interaction::DoSomething(Specie<Cat> obj){ 

std::cout << "Interact with Cat !" << std::endl; 

} 




int main(){ 


Specie<Cat> HelloKitty; 
Specie<Dog> Bobby; 

Animal *Dingo = new Specie<Dog>(); 

Animal *Tom = new Specie<Cat>(); 

// cloning Dingo 
Animal *UnknownAnimal = Dingo->clone(); 

// We check the type is correct after cloning 
UnknownAnimal->action(); 

// We check that DoSomething recognizes correctly the type of objects 
// and uses the proper specialization 
Interaction::DoSomething(Bobby); 
Interaction::DoSomething(HelloKitty); 




// Vector of pointers to Animals 
std::vector<Animal *> myanimals; 

// We add an object of type Specie<Dog> and an object 
// of type Specie<Cat> to the vector 

myanimals.push_back(&Bobby); 
myanimals.push_back(&HelloKitty); 



Animal *UnknownAnimal2 = myanimals[1]->clone(); 

// We check the type is correct after cloning 
UnknownAnimal2->action(); 



// NOW WE TRY TO USE THE ELEMENT FROM VECTOR AS ARGUMENT OF 
// SPECIALIZED FUNCTION. DOES NOT WORK. 
Interaction::DoSomething(*(myanimals[0]->clone())); 



    return 0; 
} 

error: no instance of function template "Interaction::DoSomething" matches the argument list

argument types are: (Animal) Interaction::DoSomething(*(myanimals[0]->clone()));

什么是错在我的代码？提前致谢！

Answer 1

您正在调用基类函数virtual Animal *clone() = 0;，它似乎总是返回Animal。

函数重载在编译时工作，并且不能根据参数的动态类型更改调用。为此你需要虚函数调用。使用中间级的

Answer 2

可能的解决方案：

#include <iostream> 
#include <vector> 

using namespace std; 

// Base class 
class Animal { 

public: 
    virtual ~Animal() {} 
    virtual Animal *clone() = 0; 
}; 

class InteractionAnimal : public Animal { 
public: 
    virtual ~InteractionAnimal() {} 

    virtual InteractionAnimal *clone() = 0; 
    virtual void action() const = 0; 
}; 


// Specific types of animals. Forward declaration 
class Dog; 
class Cat; 



// Templated derived class Specie 
template <class T> 
class Specie : public InteractionAnimal { 

public: 
    Specie<T> *clone(); 

    void action() const; 

}; 

template <class T> 
Specie<T> * Specie<T>::clone() { 

    std::cout << "Cloning a Specie<T>" << std::endl; 
    return new Specie<T>(*this); 

} 

// Specialization of templated function action() for Dog 
template <> 
void Specie<Dog>::action() const { 

    std::cout << "Wouaf !" << std::endl; 

} 


// Specialization of templated function action() for Cat 
template <> 
void Specie<Cat>::action() const { 

    std::cout << "Miaouuu !" << std::endl; 

} 




class Interaction { 

public: 
    static void DoSomething(const InteractionAnimal& animal) { 
     //Will be called when Type is not fully known 
     animal.action(); 
    } 

}; 

int main() { 


    Specie<Cat> HelloKitty; 
    Specie<Dog> Bobby; 

    InteractionAnimal *Dingo = new Specie<Dog>(); 

    InteractionAnimal *Tom = new Specie<Cat>(); 

    // cloning Dingo 
    InteractionAnimal *UnknownAnimal = Dingo->clone(); 

    // We check the type is correct after cloning 
    UnknownAnimal->action(); 

    // We check that DoSomething recognizes correctly the type of objects 
    // and uses the proper specialization 
    Interaction::DoSomething(Bobby); 
    Interaction::DoSomething(HelloKitty); 




    // Vector of pointers to Animals 
    std::vector<InteractionAnimal *> myanimals; 

    // We add an object of type Specie<Dog> and an object 
    // of type Specie<Cat> to the vector 

    myanimals.push_back(&Bobby); 
    myanimals.push_back(&HelloKitty); 



    InteractionAnimal *UnknownAnimal2 = myanimals[1]->clone(); 

    // We check the type is correct after cloning 
    UnknownAnimal2->action(); 



    // NOW WE TRY TO USE THE ELEMENT FROM VECTOR AS ARGUMENT OF 
    // SPECIALIZED FUNCTION. DOES NOT WORK. 
    Interaction::DoSomething(*(myanimals[0]->clone())); 



    return 0; 
} 

我已删除专门DoSomething功能，因为它们将不被调用InteractiveAnimal对象。