C++中能否扩展类/结构体的成员函数？及更优实现方案咨询

刚接触C的话，肯定会好奇能不能像一些动态语言那样，给类或者单个实例的成员函数直接追加代码逻辑——比如你伪代码里想让MyFunction先跑原有Content A，再跑新增的Content B。不过很遗憾，C是静态编译型语言，类的结构（包括成员函数的定义和绑定）在编译阶段就已经确定了，没法像你写的伪代码那样，直接在实例外面a::MyFunction()或者类外面MyStruct::MyFunction()去追加原有函数的逻辑。

不过别担心，针对你提到的两种场景，我们有很多更优雅、符合C++设计风格的实现方案：

场景A：给单个实例的MyFunction追加逻辑 #

如果只想让某一个实例的MyFunction在原有逻辑后执行新增代码，最灵活的方式是在结构体里预留一个“额外回调”的位置，用std::function来存储动态的逻辑。这样不用修改原有函数的核心结构，还能针对单个实例自定义扩展：

#include <functional>
#include <iostream>

struct MyStruct {
    // 用来存储额外要执行的逻辑，默认是空
    std::function<void()> extra_logic;

    void MyFunction() {
        // 原有Content A逻辑
        std::cout << "Content A\n";
        // 如果当前实例设置了额外逻辑，就执行
        if (extra_logic) {
            extra_logic();
        }
    }
};

int main() {
    MyStruct a;
    // 只给实例a绑定额外的Content B逻辑
    a.extra_logic = [](){
        std::cout << "Content B\n";
    };
    a.MyFunction(); // 执行顺序：Content A → Content B

    MyStruct another;
    another.MyFunction(); // 只执行Content A，不会跑B
    return 0;
}

这种方案的好处是完全动态，针对单个实例定制，不用改类的核心结构，非常适合需要临时扩展某一个实例行为的场景。

场景B：给整个类的所有实例追加MyFunction逻辑 #

如果希望所有MyStruct实例的MyFunction都执行A+B，这里分两种情况处理：

情况1：你可以修改原有MyStruct的代码 #

最直接的方式是用模板方法模式，或者给原有函数加虚函数，通过继承来扩展：

#include <iostream>

struct MyStruct {
    // 把MyFunction设为虚函数，允许子类重写扩展
    virtual void MyFunction() {
        // 原有Content A逻辑
        std::cout << "Content A\n";
    }
};

// 定义一个子类，重写MyFunction实现扩展
struct ExtendedMyStruct : MyStruct {
    void MyFunction() override {
        // 先调用父类的原有逻辑
        MyStruct::MyFunction();
        // 新增的Content B逻辑
        std::cout << "Content B\n";
    }
};

int main() {
    ExtendedMyStruct b;
    b.MyFunction(); // 执行顺序：Content A → Content B

    // 如果需要用基类指针/引用，也能多态调用扩展后的逻辑
    MyStruct* ptr = &b;
    ptr->MyFunction(); // 同样输出A→B
    return 0;
}

情况2：你不能修改原有MyStruct的代码（比如是第三方库的类） #

这时候可以用装饰器模式，通过组合的方式包装原有类，实现逻辑扩展：

#include <iostream>

// 假设这是你不能修改的原有结构体
struct MyStruct {
    void MyFunction() {
        std::cout << "Content A\n";
    }
};

// 装饰器类，用来包装MyStruct并扩展逻辑
struct MyStructDecorator {
    // 持有原有实例的引用
    MyStruct& wrapped;
    // 构造函数传入要包装的实例
    MyStructDecorator(MyStruct& s) : wrapped(s) {}

    void MyFunction() {
        // 先执行原有实例的MyFunction
        wrapped.MyFunction();
        // 新增的Content B逻辑
        std::cout << "Content B\n";
    }
};

int main() {
    MyStruct b;
    MyStructDecorator decorator(b);
    decorator.MyFunction(); // 执行顺序：Content A → Content B
    return 0;
}

额外补充：不想修改原有函数的替代方案 #

如果只是想让实例执行A+B，但不想修改原有MyFunction的行为，还可以写一个独立的非成员函数，把原有逻辑和新增逻辑组合起来：

#include <iostream>

struct MyStruct {
    void MyFunction() {
        std::cout << "Content A\n";
    }
};

// 独立函数，组合原有逻辑和新增逻辑
void MyStructWithB(MyStruct& s) {
    s.MyFunction(); // 先执行原有A
    std::cout << "Content B\n"; // 再执行B
}

int main() {
    MyStruct b;
    MyStructWithB(b); // 调用这个函数就会执行A→B
    return 0;
}

这种方案最轻量化，完全不用改原有类，适合只是偶尔需要组合逻辑的场景。

内容来源于stack exchange