C++ 有没有办法专门化继承对象的通用方法

我有两个专门的对象：

class Food {};
class Fruit : public Food {};
class Vegetable : public Food {};

然后我有一个将被继承的父类：

class Parent
{
    virtual void say(Food* obj) { std::cout << "The object is food" << std::endl; }
};

类父类
{
虚拟的虚空说（食物*obj）{std:：cout我认为解决这一问题的合适方法如下：

class Food 
{
public:
    virtual ~Food() = default;
    virtual void say() const;
};
class Fruit : public Food 
{
public:
    void say() const override { std::cout << "The object is a fruit" << std::endl; }
};
class Vegetable : public Food 
{
public:
    void say() const override { std::cout << "The object is a vegetable" << std::endl; }
};

class Parent
{
public:
    virtual ~Parent() = default;
    virtual void say(const Food& obj) const { obj.say(); }
};

class Child : public Parent {};

int main()
{
    std::vector<Food*> basket;
    Fruit fruit = Fruit();
    Vegetable vegetable = Vegetable();
    basket.push_back(&fruit);
    basket.push_back(&vegetable);

    Child child = Child();

    for (const Food* food : basket)
    {
        child.say(*food);
    }
}

类食品
{
公众：
virtual~Food（）=默认值；
虚空say（）常量；
};
水果类：公共食品
{
公众：
void say（）const override{std:：cout我认为解决这个问题的合适方法如下：

class Food 
{
public:
    virtual ~Food() = default;
    virtual void say() const;
};
class Fruit : public Food 
{
public:
    void say() const override { std::cout << "The object is a fruit" << std::endl; }
};
class Vegetable : public Food 
{
public:
    void say() const override { std::cout << "The object is a vegetable" << std::endl; }
};

class Parent
{
public:
    virtual ~Parent() = default;
    virtual void say(const Food& obj) const { obj.say(); }
};

class Child : public Parent {};

int main()
{
    std::vector<Food*> basket;
    Fruit fruit = Fruit();
    Vegetable vegetable = Vegetable();
    basket.push_back(&fruit);
    basket.push_back(&vegetable);

    Child child = Child();

    for (const Food* food : basket)
    {
        child.say(*food);
    }
}

类食品
{
公众：
virtual~Food（）=默认值；
虚空say（）常量；
};
水果类：公共食品
{
公众：
void say（）常量重写{std:：难道不同的食物应该以多态方式打印自己。然后你只需在你的
say
函数中调用该函数。在现实世界中，孩子知道自己在吃什么。在OOP中，食物知道自己的名字。我想问题是，你不能调用一个重载方法，期望多态性来找出哪个方法调用。不同的食物应该以多态方式打印自己。然后你只需在你的
say
函数中调用该函数。在现实世界中，孩子知道自己在吃什么。在OOP中，食物知道自己的名字。我想问题是，你不能调用一个重载的方法，期望多态性来确定是什么ch方法调用。非常感谢你的回答。但是如果说会给孩子增加健康呢？@Talesseed:你也可以在
食品
@Jarod42中作为添加方法的替代方法，谢谢，虽然这里不会使用这种模式，因为它会使需要非常简单的类复杂化。@Talesseed:这是一种交易。你必须考虑如果添加新的方法，或者在层次结构中添加新的类。你认为是你的基类的一部分。从你的例子中，你甚至不需要层次结构，而简单的成员来存储健康和身份就足够了。@ JAROD42我想我需要层次结构来存储“食物”。在一个单独的容器里，不是吗？否则，我肯定会认为这是一个选择（我以前也不知道，谢谢）谢谢你的回答。但是，如果说“例如，给孩子增加健康”会怎么样？@ TaleStEY:你也可以在“代码>食物< /代码>中选择替代方法。@ JAROD42谢谢，虽然这里不使用这种模式，因为它会使一个需要很简单的类复杂化。”TaleStEn:这是一个交易。你必须考虑是否有新的方法。将被添加，或者在层次结构中添加新的类。你认为是你的基类的一部分。从你的例子中，你甚至不需要层次结构，而简单的成员来存储健康和身份就足够了。在一个单独的容器里，不是吗？否则，我肯定会认为这是一个选择（我以前也不知道，谢谢）。
class Food 
{
public:
    virtual ~Food() = default;
    virtual void say() const;
};
class Fruit : public Food 
{
public:
    void say() const override { std::cout << "The object is a fruit" << std::endl; }
};
class Vegetable : public Food 
{
public:
    void say() const override { std::cout << "The object is a vegetable" << std::endl; }
};

class Parent
{
public:
    virtual ~Parent() = default;
    virtual void say(const Food& obj) const { obj.say(); }
};

class Child : public Parent {};

int main()
{
    std::vector<Food*> basket;
    Fruit fruit = Fruit();
    Vegetable vegetable = Vegetable();
    basket.push_back(&fruit);
    basket.push_back(&vegetable);

    Child child = Child();

    for (const Food* food : basket)
    {
        child.say(*food);
    }
}

class Food 
{
public:
    virtual ~Food() = default;
    virtual void say() const;
    virtual int health() const;
};
class Fruit : public Food 
{
public:
    void say() const override { std::cout << "The object is a fruit" << std::endl; }
    int health() const override { return 5; }
};
class Vegetable : public Food 
{
public:
    void say() const override { std::cout << "The object is a vegetable" << std::endl; }
    int health() const override { return 10; }
};

class Parent
{
public:
    virtual ~Parent() = default;
    virtual void say(const Food& obj) const { obj.say(); }
};

class Child : public Parent 
{
    int health;

public:
    void eat(const Food& obj) { health += obj.health(); }
};

int main()
{
    std::vector<Food*> basket;
    Fruit fruit = Fruit();
    Vegetable vegetable = Vegetable();
    basket.push_back(&fruit);
    basket.push_back(&vegetable);

    Child child = Child();

    for (const Food* food : basket)
    {
        child.say(*food);
        child.eat(*food);
    }
}