C++如何在子类中实现父类成员对象的方法重写

下面给出两种工业界常用的实现方案：

方案1：抽象基类+多态（经典面向对象实现） #

核心思路是将Brain定义为抽象基类，把需要自定义的changeSpeed声明为纯虚函数，在Car类内部定义Brain的派生类，各自实现对应的调速逻辑。需要注意原代码中User存储Brain值会导致对象切片，需改为存储智能指针保证多态生效。
修改后核心代码示例：

#include <memory>
// 前置声明Car类
class Car;
// 抽象Brain基类
class Brain{
public:
    Brain(std::string name):name(name){}
    virtual ~Brain() = default; // 多态基类必须有虚析构函数
    std::string getName(){
        return this->name;
    }
    virtual void changeSpeed(Car* car) = 0; // 传入Car指针操作speed成员
private:
    std::string name;
};

class User{
public:
    void addBrain(std::unique_ptr<Brain> b){
        brains_.push_back(std::move(b));
    }
    void showBrains(){
        for(auto &b:brains_){
            std::cout << b->getName() << std::endl;
        }
    }
    void apply(int index, Car* car){
        brains_[index]->changeSpeed(car);
    }
private:
    std::vector<std::unique_ptr<Brain>> brains_;
};

class Car: public User{
    // 内部定义两种Brain实现
    class AddSpeedBrain : public Brain {
    public:
        AddSpeedBrain(std::string name) : Brain(name) {}
        void changeSpeed(Car* car) override {
            car->speed += 1;
        }
    };
    class SubSpeedBrain : public Brain {
    public:
        SubSpeedBrain(std::string name) : Brain(name) {}
        void changeSpeed(Car* car) override {
            car->speed -= 1;
        }
    };
public:
    Car(){
        // 实例化派生类Brain加入列表
        addBrain(std::make_unique<AddSpeedBrain>("one"));
        addBrain(std::make_unique<SubSpeedBrain>("two"));
    }

    void change(int index){
        this->apply(index, this);
        std::cout << "car speed " << getSpeed() << std::endl;
    }

    int getSpeed(){
        return this->speed;
    }

private:
    int speed=0;
};

该方案适合Brain还有其他自定义接口、逻辑复杂度较高的场景，扩展性强，符合面向对象设计规范。

方案2：std::function回调绑定（轻量灵活实现） #

如果只需要自定义changeSpeed单个方法，不需要多套扩展接口，可以用回调的方式实现，不需要继承层级，代码更简洁。
核心思路是在Brain内部存储一个可调用对象，创建Brain实例时直接传入Car中定义的lambda表达式作为changeSpeed的实现，lambda可以直接捕获Car的this指针操作成员变量。
修改后核心代码示例：

#include <functional>
class Brain{
public:
    Brain(std::string name, std::function<void()> func):name(name), change_func(std::move(func)){}
    std::string getName(){
        return this->name;
    }
    void changeSpeed(){
        if (change_func) change_func();
    }
private:
    std::string name;
    std::function<void()> change_func; // 存储自定义逻辑
};

class User{
public:
    void addBrain(Brain b){
        brains_.push_back(std::move(b));
    }
    void showBrains(){
        for(auto &b:brains_){
            std::cout << b.getName() << std::endl;
        }
    }
    void apply(int index){
        brains_[index].changeSpeed();
    }
private:
    std::vector<Brain> brains_;
};

class Car: public User{
public:
    Car(){
        // 创建Brain时直接传入对应逻辑的lambda
        Brain one("one", [this](){
            this->speed +=1;
        });
        Brain two("two", [this](){
            this->speed -=1;
        });
        addBrain(std::move(one));
        addBrain(std::move(two));
    }

    void change(int index){
        this->apply(index);
        std::cout << "car speed " << getSpeed() << std::endl;
    }

    int getSpeed(){
        return this->speed;
    }

private:
    int speed=0;
};

该方案代码量更少，灵活性更高，适合单方法自定义的轻量场景，不需要维护复杂的继承关系。

内容的提问来源于stack exchange，提问作者Xgo