C++成员函数引用的替代方案与计算性能优化问题

众所周知，C++中不存在成员函数的引用，也不能用普通函数指针直接指向成员函数——因为成员函数调用时需要绑定类实例的this指针，普通函数指针无法携带这个上下文。

比如你尝试写这样的代码：

class A
{
public:
    void Add(int a, int b)
    {
        std::cout << "Sum is " << a + b << std::endl;
    }

    void CallAdd(int a, int b, void (*func)(int, int))
    {
        func(a, b);
    }
};

然后调用：

A a;
a.Add(3, 7); // 正常运行
a.CallAdd(3, 7, &A::Add); // 编译失败

会得到错误：

error: cannot create a non-constant pointer to member function
a.CallAdd(3, 7, &A::Add);

用std::function+lambda的方案虽然能运行，但std::function的类型擦除特性会带来额外性能开销，对于积分算法这类需要高频调用的场景并不理想。以下是几种更高效的替代方案：

方案1：使用成员函数指针 #

成员函数指针是C++专门为成员函数设计的类型，能正确绑定类的上下文，且无额外性能开销：

class A
{
public:
    void Add(int a, int b)
    {
        std::cout << "Sum is " << a + b << std::endl;
    }

    // 明确声明成员函数指针参数类型
    void CallAdd(int a, int b, void (A::*func)(int, int))
    {
        (this->*func)(a, b); // 通过this调用成员函数指针
    }
};

int main()
{
    A a;
    a.CallAdd(3, 7, &A::Add); // 正常编译运行
}

这种方式性能和直接调用成员函数几乎一致，但缺点是只能接受当前类的成员函数，灵活性有限。

方案2：模板+任意可调用对象（推荐） #

如果需要灵活切换不同类型的被积函数（普通函数、lambda、其他类成员函数等），可以用模板避免std::function的类型擦除开销，编译器能对调用做完全优化：

class A
{
public:
    void Add(int a, int b)
    {
        std::cout << "Sum is " << a + b << std::endl;
    }

    // 模板函数接受任意可调用对象
    template<typename Func>
    void CallAdd(int a, int b, Func&& func)
    {
        std::forward<Func>(func)(a, b);
    }
};

// 普通函数示例
void NormalAdd(int x, int y)
{
    std::cout << "Normal sum: " << x + y << std::endl;
}

int main()
{
    A a;
    // 绑定当前实例的成员函数
    a.CallAdd(3, 7, std::bind(&A::Add, &a, std::placeholders::_1, std::placeholders::_2));
    
    // 捕获this的lambda（无额外开销，编译器可内联）
    a.CallAdd(3, 7, [&a](int x, int y){ a.Add(x, y); });
    
    // 传递普通函数
    a.CallAdd(3, 7, NormalAdd);
}

这种方案兼顾灵活性和性能，是积分算法这类场景的最优选择——既能随时切换被积函数，又能保证调用效率。

方案3：仿函数（函数对象） #

如果被积函数需要携带状态，可以封装成仿函数类，同样能被编译器完全优化：

struct AddFunc
{
    void operator()(int a, int b) const
    {
        std::cout << "Sum is " << a + b << std::endl;
    }
};

class A
{
public:
    template<typename Func>
    void CallAdd(int a, int b, Func func)
    {
        func(a, b);
    }
};

int main()
{
    A a;
    a.CallAdd(3, 7, AddFunc{});
}

仿函数的优势是可携带自定义状态，同时性能和直接调用无差别。

性能对比 #

• 成员函数指针：性能接近直接调用，仅支持当前类成员函数
• 模板+可调用对象：性能最优，支持所有可调用类型，灵活高效
• 仿函数：性能优异，适合需要携带状态的函数
• std::function：有运行时类型擦除开销，仅适合对性能要求不高的场景

内容的提问来源于stack exchange，提问作者João Viana