C++ C++；

我需要调用一个需要函数指针的方法，但我真正想要传递给它的是一个函子。下面是我尝试做的一个例子：

#include <iostream>
#include "boost/function.hpp"

typedef int (*myAdder)(int);

int adderFunction(int y) { return(2 + y); }

class adderClass {
  public:
    adderClass(int x) : _x(x) {}  
    int operator() (int y) { return(_x + y); }

  private:
    int _x;
};

void printer(myAdder h, int y) {
  std::cout << h(y) << std::endl;
}

int main() {
  myAdder f = adderFunction;

  adderClass *ac = new adderClass(2);
  boost::function1<int, int> g =
    std::bind1st(std::mem_fun(&adderClass::operator()), ac);

  std::cout << f(1) << std::endl;
  std::cout << g(2) << std::endl;
  printer(f, 3);
  printer(g, 4); // Is there a way to get this to work?
}

#包括
#包括“boost/function.hpp”
typedef int（*myAdder）（int）；
整数加法函数（inty）{返回（2+y）；}
类加法器类{
公众：
加法器类（int x）：x（x）{}
int运算符（）（int y）{return（x+y）；}
私人：
int_x；
};
无效打印机（myAdder h，int y）{
std：：cout像这样：

template<typename AdderT>
void printer(AdderT h, int y) {
  std::cout << h(y) << std::endl;
}

虽然boost函数的行为类似于普通函数指针，但它是另一种类型。因此，您不能仅将boost函数分配给函数指针

在代码中，您可以简单地替换

typedef int (*myAdder)(int);

与

typedef boost:：function1myAdder；

一切都会好起来。
好的，下面是另一个尝试：

class CallProxy
{
public:
    static adderClass* m_instance;
    static int adder(int y)
    {
        return (*m_instance)(y);
    }
};

adderClass* CallProxy::m_instance = NULL;


int main() {
    myAdder f = adderFunction;

    adderClass ac(2);

    std::cout << f(1) << std::endl;
    std::cout << ac(2) << std::endl;
    printer(f, 3);
    CallProxy::m_instance = &ac;
    printer(CallProxy::adder, 4); 
}

class调用代理
{
公众：
静态加法器类*m_实例；
静态整数加法器（整数y）
{
返回（*m_实例）（y）；
}
};
adderClass*CallProxy:：m_instance=NULL；
int main（）{
我的加法器f=加法器函数；
加法器类ac（2）；
std：：这可能行得通，但是（我忘了提到），方法“printer”在代码中我无法更改。我控制的只是方法“main”和类“adderClass”。它也不是可重入的：如果
printer
调用
main
你就有麻烦了。但我认为，考虑到这些限制，这是最好的方法，至少是可移植的。对于不可移植的解决方案，例如，你可以动态生成代码。@Steve Jessop:任何调用
main（）
的方法都会导致未定义的行为（§3.6.1/2：“不得在程序中使用函数main（3.2）”@Jerry Coffin-请尝试超越这个愚蠢示例的有限范围。
typedef boost::function1< int, int > myAdder;

class CallProxy
{
public:
    static adderClass* m_instance;
    static int adder(int y)
    {
        return (*m_instance)(y);
    }
};

adderClass* CallProxy::m_instance = NULL;


int main() {
    myAdder f = adderFunction;

    adderClass ac(2);

    std::cout << f(1) << std::endl;
    std::cout << ac(2) << std::endl;
    printer(f, 3);
    CallProxy::m_instance = &ac;
    printer(CallProxy::adder, 4); 
}