对基向量的元素调用派生方法（给出的示例）

Question

假设我有以下类结构。我希望能够确定 Animal 向量中的元素是什么类类型，以便我可以对其执行特定于子类的方法。下面的例子应该演示：

#include <iostream>
#include <vector>

using namespace std;

class Animal {
    public:
    int foodcount;

    Animal() {
        foodcount = 0;
        cout << "An animal was created.\n";
    }
    virtual ~Animal() {
        cout << "An animal was destroyed.\n";
    }
};

class Lion : public Animal {
    public:
    Lion() {
        cout << "A lion was created.\n";
    }
    virtual ~Lion() {
        cout << "A lion was destroyed.\n";
    }
    void chowMeat(int howmuch) {
        foodcount += howmuch;
    }
};

class Butterfly : public Animal {
    public:
    Butterfly() {
        cout << "A butterfly was created.\n";
    }
    virtual ~Butterfly() {
       cout << "A butterfly was destroyed.\n";
    }
    void drinkNectar(int howmuch) {
       foodcount += howmuch;
    }
};

int main() {
    Animal* A = new Lion();
    Animal* B = new Butterfly();
    vector<Animal*> v;

    v.push_back(A);
    v.push_back(B);

    // a little later

    for (int i=0; i<v.size(); i++) {
        if (v[i] is a Lion) v[i]->chowMeat();  // will not work of course
        if (v[i] is a Butterfly) v[i]->drinkNectar();   // will not work of course
    }

    std::cin.get();
    return 0;
}

显然标记的代码不起作用，但是我该如何做我想做的事情呢？是否有我应该遵循但没有遵循的解决方法或设计原则？我研究过dynamic_cast，但明白这很不漂亮。那么我应该怎样做才正确呢？

在Java中，我会这样做：

if (v.get(i).getClass() == Lion.class) {
    ((Lion)v.get(i)).chowMeat();
}
if (v.get(i).getClass() == Butterfly.class) {
    ((Butterfly)v.get(i)).drinkNectar();
}

Answer 1

理想情况下，您可以向基类添加一个虚函数 void eat(int amount) 并在派生类中重写该函数。

在这种情况下，使该函数成为非虚拟函数并在基类中实现它甚至可能是有意义的，因为两个派生类都执行完全相同的操作。

除此之外，您可以使用 dynamic_cast 来测试对象的动态类型：（

if (Lion* lion = dynamic_cast<Lion*>(v[i])) {
    lion->chowMeat(42); 
}
else if (Butterfly* butterfly = dynamic_cast<Butterfly*>(v[i])) {
    butterfly->drinkNectar(42);
}
// etc.

另一方面，您需要非常小心地在 C++ 中使用裸指针；编写正确的代码非常困难在您手动管理资源的情况下，您尚未释放 A 和 B 指向的对象，因此考虑使用智能指针，例如 <。 code>shared_ptr，自动管理您的资源。）

Answer 2

循环的目的是什么？是为了吃东西吗？在这种情况下，请将 virtual void ConsumerFood(int howMuch) 添加到您的基类，并在派生类中重写它。

Answer 3

如果这个例子确实具有代表性，那么虚拟函数将更巧妙地解决您眼前的问题。

无论如何，如果您的类具有虚函数，最简单的答案是使用dynamic_cast来检查对象是否属于给定类型。例如：

for (int i=0; i<v.size(); i++) {
    if (Lion *lion = dynamic_cast<Lion *>(v[i]))
        lion->chowMeat();
    else if(Butterfly *butterfly = dynamic_cast<Butterfly *>(v[i]))
        butterfly->drinkNectar();
}

它是内置于语言中的，只是用于检查指向基类的指针是否实际上指向更派生类型的对象。

另一种选择是在基类中拥有某种虚拟 GetType 函数，您可以在每个类中重写该函数以返回唯一标识该类的内容（整数、对象等）。然后，您在运行时调用此函数，并检查结果以找出所指向的对象类型。

dynamic_cast 的优点是内置于语言中，并且不需要您付出任何努力来支持。使用自己的函数在各种编译器中具有更可预测的性能特征，并且允许存储除对象实际类型之外的数据 - 但您必须自己编写所有数据。

Answer 4

为什么不吃（）？

class Animal {
    public:
    int foodcount;

    Animal() {
        foodcount = 0;
        cout << "An animal was created.\n";
    }
    virtual ~Animal() {
        cout << "An animal was destroyed.\n";
    }
    virtual void eat(int howMuch) {
        foodcount += howmuch;
    }
};

class Lion : public Animal {
    public:
    virtual void eat(int howmuch) {
        Animal::eat(howmuch + 19);
    }
};

class Butterfly : public Animal {
    void eat(int howmuch) {
       Animal::eat(howmuch / 1000);
    }
};

class Tribble: public Animal
{
    void eat(int howmuch) {
       throw DontFeedTribles();
    }
};

int main() {
    std::auto_ptr<Animal> A = new Lion();
    std::auto_ptr<Animal> B = new Butterfly();
    vector<Animal*>  menagerie;

    menagerie.push_back(A.get());
    menagerie.push_back(B.get());

    BOOST_FOREACH(Animal* animal, menagerie)
    {
        animal->eat(10000);
    }

    std::cin.get();
    return 0;
}