C ++继承：具有基类类型的虚函数中派生类类型的参数

Question

我遇到了一个特殊的 C++ 继承问题。假设我们有两个抽象类，一个使用另一个作为纯虚函数之一的参数类型：

class Food {
  public:
    int calories=0;
    virtual void set_calories(int cal)=0;
}

class Animal {
  public:
   int eaten_calories=0;
   virtual void eat_food(Food &f)=0;
}

现在，我们为每个类创建一个派生类，我们用派生类类型的参数实例化一个虚函数：

class Vegetables: public Food{
  public:
   void set_calories(int cal){calories=cal;}
}
class Cow: public Animal{
  public:
   void eat_food(Vegetables &v){this->eaten_calories += v.calories;}
}

这个问题是函数eat_food需要一个抽象类Food的签名，否则Cow()对象创建将无法编译，抱怨Cow是一个抽象类，因为没有合适的找到了eat_food(Food f) 的实现。

更新：我寻求实现的另一个限制是第二个class Meat: public Food 不应该与Cow::eat_food(f) 一起使用。简而言之，仅设置 Cow::eat_food(Food f) 并强制转换为 Vegetables 不会成功。

克服此错误的最佳方法是什么？

到目前为止，我找到了两个选择：

1. 在Cow 中使用try/catch 创建eat_food(Food f) 实现，以检查f 是否可以安全地转换为Vegetables，然后调用eat_food(Vegetables v)。 问题：如果你有 50 个虚函数，这将迫使你在 Cow 中编写 50 个额外的函数实现。
2. 将Animal 转换为模板类Animal<T>，并使用Food 的每个派生类对其进行实例化以定义动物（例如class Cow: public Animal<Vegetables>）。 问题：您不能再定义 Animal* 指针来保存类型未知的未定义动物。

这两者有什么可行/时尚的替代品吗？也许是某种软件模式？

Answer 1

当您定义接受Food& 参数的虚函数Animal::eat_food() 时，您声明对于任何Animal，您可以将任何Food 提供给eat_food()。现在你想打破这个承诺。这会质疑您的设计。调用ptr->eat_food(food) 是合法的，其中ptr 是Animal*，food 是Meat，或者eat_food() 不应该（可能）在Animal 类中定义。如果您不能将一个Food 替换为另一个，则使用Food& 可能是一个错误。如果您不能将一个Animal 替换为另一个，那么在Animal 级别定义可能是一个错误。

也许命名法上的一个小改变会有助于使这更有意义。考虑将eat_food 重命名为give_food，或者可能是feed。现在你有了一个适用于所有动物的概念。你可以给任何动物喂任何食物，但动物是否吃它是另一回事。也许你应该让你的虚函数feed() 让它同样适用于所有动物。如果你有一个Animal* 和一个Food&，你可以喂动物，但决定它是否吃东西的是动物。如果您坚持在输入Animal 之前必须知道Food 的正确类型，那么您应该使用Cow* 而不是Animal*。

注意：如果您碰巧从未尝试提供 Animal*，那么您可以从 Animal 中删除虚函数，在这种情况下，您的问题将变得没有意义.

这可能类似于以下内容。

class Animal {
    int eaten_calories=0;
  protected:
    void eat_food(Food &f) { eaten_calories += f.calories; }  // Not virtual
  public:
    virtual void feed(Food &f)=0;
};

class Cow: public Animal{
  public:
    void feed(Food &f) override {
        // Cows only eat Vegetables.
        if ( dynamic_cast<Vegetables*>(&f) ) // if `f` is a Vegetables
            eat_food(f);
        else
            stampede(); // Or whatever you think is amusing (or appropriate).
    }
};

请注意，我保留了您的 eat_food() 实现，但将其移至 Animal 中的非虚拟函数。这是基于假设的，因此可能不合适。但是，我愿意假设，无论哪种动物，无论哪种食物，如果动物真的吃了食物，那么所吃的卡路里应该会增加食物的卡路里。

此外，根据经验，这可能是正确的抽象级别——所使用的两位数据，calories 和 eaten_calories，直接属于所使用的两个类，Animal和Food。这表明（只是一个经验法则）您的逻辑和数据处于一致的抽象级别。

哦，我还为eat_food() 指定了protected 访问权限。这样，是否吃东西由对象决定。没有人可以强迫动物吃东西；他们只能提供食物。这证明了多态设计的另一个原则：当派生类不同时，只有这些类的对象需要知道这些差异。只看到公共基础对象的代码不需要在使用这些对象之前测试这些差异。

Answer 2

如果您将多态类型（如Vegetables）作为基类型按值（如Food f）传递，您将使用slice the object，从而防止调用被覆盖的方法。

您需要通过指针或通过引用传递此类类型，例如：

class Food {
public:
    virtual int get_calories() const = 0;
};

class Animal {
public:
    int eaten_calories = 0;
    virtual void eat_food(Food& f) = 0;
};

class Vegetables: public Food {
public:
    int get_calories() const { return ...; }
};

class Cow: public Animal{
public:
    void eat_food(Food& f){ this->eaten_calories += f.get_calories(); }
};

Vegetables veggies;
Cow cow;
cow.eat_food(veggies);

更新：

您不能更改派生类中虚方法的签名（使用协变返回类型时除外）。由于eat_food() 在Animal 中公开并采用Food&，如果您希望Cow::eat_food() 只接受Vegetables 对象而不接受Meat 对象，那么它需要在运行时检查输入@ 987654332@ 指的是 Vegetables 对象，如果不是，则抛出异常。 dynamic_cast 在投射参考时会为您执行此操作，例如：

class Cow: public Animal{
public:
    void eat_food(Food& f){ this->eaten_calories += dynamic_cast<Vegetables&>(f).calories; }
};

Vegetables veggies;
Meat meat;
Cow cow;
cow.eat_food(veggies); // OK
cow.eat_food(meat); // throws std::bad_cast