如何拦截C++方法调用并记录被调用的方法名称？

你已经了解可以通过重载->运算符实现类方法调用前自动执行某个前置函数，但现在需要让这个前置函数能知道具体被调用的是哪个方法。以下结合你的示例场景给出可行解决方案：

先回顾你的基础代码结构：

struct Foo{
    void func1(){ }
    void func2(){ }
};

struct Bar{
    void someFunc(Foo* f){
        f->func1();
    }
};

struct Baz{
    void someFunc(Foo* f){
        f->func2();
    }
};

你提到的两种初步方案各有局限：

• 手动在每个方法内加日志代码：侵入性强，需要逐个修改方法实现；
• 继承重载->的方式：只能触发前置函数，但无法获取后续要调用的方法名。

可行解决方案 #

方案1：代理对象+成员函数指针包装 #

创建一个能捕获方法名的代理类，通过包装成员函数指针，在实际调用方法前记录日志。这种方式无需修改原Foo类的代码：

#include <iostream>
#include <string>

struct Foo{
    void func1(){ std::cout << "执行func1\n"; }
    void func2(){ std::cout << "执行func2\n"; }
};

// 用于包装方法的代理类
template<typename T>
struct MethodLogger {
    T* target_obj;
    void (T::*target_method)();
    std::string method_name;

    MethodLogger(T* obj, void (T::*method)(), const std::string& name) 
        : target_obj(obj), target_method(method), method_name(name) {}

    void operator()() {
        // 执行前置日志逻辑
        std::cout << "日志：调用方法 " << method_name << "\n";
        // 调用原方法
        (target_obj->*target_method)();
    }
};

// 包装Foo的日志类
struct LoggingFoo {
    Foo inner_foo;

    // 为每个方法返回对应的代理对象
    MethodLogger<Foo> func1() {
        return MethodLogger<Foo>(&inner_foo, &Foo::func1, "func1");
    }

    MethodLogger<Foo> func2() {
        return MethodLogger<Foo>(&inner_foo, &Foo::func2, "func2");
    }
};

// 使用示例
int main() {
    LoggingFoo logged_foo;
    logged_foo.func1(); // 先输出日志，再执行func1
    logged_foo.func2(); // 先输出日志，再执行func2

    Bar bar;
    // 若要兼容原Bar的调用方式，可调整LoggingFoo的访问权限或增加适配接口
    // bar.someFunc(&logged_foo.inner_foo);
    return 0;
}

方案2：宏自动注入日志代码 #

通过宏定义批量为方法添加前置日志逻辑，无需手动修改每个方法的实现，同时自动获取方法名：

#include <iostream>
#include <string>

// 定义日志注入宏
#define ADD_LOG_TO_METHOD(method_name) \
    void method_name() { \
        log(#method_name); \
        real_##method_name(); \
    } \
    void real_##method_name()

struct Foo{
    // 用宏替换原方法声明
    ADD_LOG_TO_METHOD(func1) {
        std::cout << "执行func1\n";
    }

    ADD_LOG_TO_METHOD(func2) {
        std::cout << "执行func2\n";
    }

    // 通用日志函数
    void log(const std::string& method_name) {
        std::cout << "日志：调用方法 " << method_name << "\n";
    }
};

// 使用示例
int main() {
    Foo f;
    f.func1();
    f.func2();

    Bar bar;
    bar.someFunc(&f); // 完全兼容原有调用方式
    return 0;
}

方案3：编译期AOP工具（如AspectC++） #

如果是大型项目，可以使用面向切面编程（AOP）工具，在编译阶段自动为类的所有方法添加前置日志逻辑。这种方式无需修改原有代码，且能自动捕获方法名，但需要额外的编译工具支持，不属于标准C++范畴。

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