是否可以在从用户那里抽象指针的同时支持多态方法调用?

Question

问题

我试图在我的代码中支持某种程度的多态性。我基本上想覆盖子类(Dog和Duck)中str的方法，然后使用智能指针指向另一个类(AnimalContainer)中的超类Animal来调用str方法。具体来说，我想支持以下 API：

int main(){
Duck duck;
Dog dog;
AnimalContainer duckInContainer(duck);
std::cout << duckInContainer.str() << std::endl; // Outputs "None" but should output "Duck"

AnimalContainer dogInContainer(dog);
std::cout << dogInContainer.str() << std::endl; // Outputs "None" but should output "Dog"
}

这里缺少指针是故意的。我打算将其作为API的前端，并希望使其尽可能简单。因此，如果可能的话，我希望避免让用户自己显式创建(比如)Dog指针。换句话说，我想避免让用户做这样的事情：

Dog dog;
std::unique_ptr<Dog> dog_ptr = std::make_unique<Dog>(dog);
AnimalContainer animalContainer(dog_ptr)
std::cout << animalContainer.str() << std::endl;

上述是否可能，如果是，我需要对以下代码进行哪些更改：

代码

#include <iostream>
#include <vector>
#include <memory>
using namespace std;

class Animal {
public:
Animal() = default;
virtual std::string str() {
return "None";
}
};
class Duck : public Animal {
public:
using Animal::Animal;
std::string str() override {
return "Duck";
}
};
class Dog : public Animal {
public:
using Animal::Animal;
std::string str() override {
return "Dog";
}
};
typedef std::unique_ptr<Animal> AnimalPtr;

class AnimalContainer {
private:
AnimalPtr animal_ptr;
public:
explicit AnimalContainer(const Animal& animal){
this->animal_ptr = std::make_unique<Animal>(animal);
}
explicit AnimalContainer(AnimalPtr animal_ptr){
this->animal_ptr = std::make_unique<Animal>(*animal_ptr);
}
std::string str(){
return this->animal_ptr->str();
}
};

到目前为止，我认为这条线

this->animal_ptr = std::make_unique<Animal>(animal);

是问题所在，因为Dog或Duck被切成Animal。但是，另一种方法是明确说明我们想要的动物类型，又名

std::unique_ptr<Dog> dog_ptr = std::make_unique<Dog>(Dog())

Answer 1

如果没有克隆功能，您可能会执行以下操作：

class AnimalContainer {
private:
AnimalPtr animal_ptr;
public:
explicit AnimalContainer(const Dog& dog){
this->animal_ptr = std::make_unique<Dog>(dog);
}
// Same for Duck
explicit AnimalContainer(AnimalPtr animal_ptr){
this->animal_ptr = std::move(animal_ptr));
}
std::string str(){ return this->animal_ptr->str(); }
};

或者更一般地说：

class AnimalContainer {
private:
AnimalPtr animal_ptr;
public:
template <typename T>
explicit AnimalContainer(const T& animal){
this->animal_ptr = std::make_unique<T>(animal);
}
explicit AnimalContainer(AnimalPtr animal_ptr){
this->animal_ptr = std::move(animal_ptr));
}
std::string str(){ return this->animal_ptr->str(); }
};