c++ - 从指向 boost::any 的指针调用可变参数模板

Question

我正在尝试创建一个具有不同参数和返回类型的函数映射。所以，为了做到这一点，我通过 stackoverflow 进行了很多搜索，我想我得到了我需要的东西，但不完全是......

背景:

来自 this帖子，答案来自pmr是我需要的最准确的解决方案。因此，我已将函数 call 扩展为可变参数模板(我希望如此)。所以，这是我的调用版本(AnyCaller 类的其余部分完全相同):

   template<typename Ret, typename ...Args>
   Ret call(const std::string& s, Args&&... arg) {
     // we have to assume that our users know what we are actually returning here
     const boost::any& a = calls[s];
     return boost::any_cast< std::function<Ret(Args...)> >(a)(std::forward<Args>(arg)...);
   }

它编译正常。现在，这些是我用来测试该类的三个函数:

int foo() { MessageBoxW(nullptr, L"Helolo VOID", L"Info", NULL); return 1; }
double foo2(std::wstring str) { MessageBoxW(nullptr, str.data(), L"Info", NULL); return double(4.5); }

UINT foo3(std::wstring str1, std::wstring str2) 
{ 
  std::wstring strBuffer;

  strBuffer = str1;
  strBuffer += L"==>";
  strBuffer += str2;
  MessageBoxW(nullptr, strBuffer.data(), L"Info", NULL); 

  return 4; 
}

因此，第一个的签名为 int(void)，第二个 double(std::wstring) 和第三个 double(std: :wstring, std::wstring).

现在，这是测试代码:

  AnyCaller c;
  c.add("foo1", std::function<int(void)>(foo));
  c.add("foo2", std::function<double(std::wstring)>(foo2));
  c.add("foo3", std::function<UINT(std::wstring, std::wstring)>(foo3));

  c.call<int>("foo1");
  c.call<double, std::wstring>("foo2", std::wstring(L"foo2!!!").data());
  c.call<UINT, std::wstring, std::wstring>("foo3", std::wstring(L"foo3!!!").data(), std::wstring(L"---foo3!!!").data());

一切顺利:)

所以，虽然这工作正常，但我真正需要的是添加对函数成员的支持。基本上，我所做的是创建一个 A 类，它具有完全相同的三个函数和一些用于测试目的的函数:

class A
{
public:
  int foo() { MessageBoxW(nullptr, L"Helolo VOID", L"Info", NULL); return 1; }
  double foo2(std::wstring str) { MessageBoxW(nullptr, str.data(), L"Info", NULL); return double(4.5); }

  UINT foo3(std::wstring str1, std::wstring str2)
  {
    std::wstring strBuffer;

    strBuffer = str1;
    strBuffer += L"==>";
    strBuffer += str2;
    MessageBoxW(nullptr, strBuffer.data(), L"Info", NULL);

    return 4;
  }

  std::wstring foo4(VOID) { return std::wstring(L"foo4"); }
  std::wstring foo5(std::wstring strData) { return (strData + L"--foo5"); }
  VOID foo6(VOID) { ; }
};

但是我无法让它工作。我的第一个问题是添加指向成员函数的指针:

A a;
c.add("foo1", std::function<int(void)>(&A::foo)); // => Not valid
c.add("foo1", std::function<int(void)>(&a.foo));  // => Not valid
c.add("foo1", &a.foo);                            // => Not valid
c.add("foo1", a.foo);                             // => Not valid
c.add("foo1", ?????); //What in heaven goes here?

显然一定是 a 的某种转换，但我无法想象是什么......

当然，在那之后，我需要做实际的调用:

int nRet = c.call<int>("foo1");

感谢任何可以提供帮助的人:_)

PS:我不能做静态成员，如果这是一个解决方案...

PS2:我正在使用 VS2013...

解决方案:

感谢@Kiroxas、@Praetorian 和 this 的评论帖子，我提出了一个不涉及可变参数模板的解决方案。

这些是我的测试类 A 和 B:

class A
{
public:
  int foo1() { MessageBoxW(nullptr, L"Helolo VOID", L"Info", NULL); return 1; }
  int foo2(std::wstring str) { MessageBoxW(nullptr, str.data(), L"Info", NULL); return 5; }

  int foo3(std::wstring str1, std::wstring str2)
  {
    std::wstring strBuffer;

    strBuffer = str1;
    strBuffer += L"==>";
    strBuffer += str2;
    MessageBoxW(nullptr, strBuffer.data(), L"Info", NULL);

    return 4;
  }
};

class B
{
public:
  std::wstring foo4(VOID) { return std::wstring(L"foo4"); }
  std::wstring foo5(std::wstring strData) { return (strData + L"--foo5"); }
  VOID foo6(VOID) { ; }
  double foo7(std::wstring str1, int nNum) 
  {
    std::wstring strBuffer;

    strBuffer = str1;
    strBuffer += L"==>";
    strBuffer += std::to_wstring(nNum);
    MessageBoxW(nullptr, strBuffer.data(), L"Info", NULL);

    return double(3.1415);
  }
};

这是将它们插入数组并调用它们的代码 :) 我理想的解决方案是将它们插入 map ，所以，一旦我完成所有工作，我将再次更新 ¡帖子。

      typedef struct
      {
        UINT ID;
        std::wstring NAME;
        boost::any Func;
      } funcs;
      funcs CallBackItems[] =
      {
        //From class A
        { 0, L"foo1", std::function<int(void)>(std::bind(&A::foo1, a)) },
        { 1, L"foo2", std::function<int(std::wstring)>(std::bind(&A::foo2, a, std::placeholders::_1)) },
        { 2, L"foo3", std::function<int(std::wstring, std::wstring)>(std::bind(&A::foo3, a, std::placeholders::_1, std::placeholders::_2)) },
        //From class B
        { 3, L"foo4", std::function<std::wstring(void)>(std::bind(&B::foo4, b)) },
        { 4, L"foo5", std::function<std::wstring(std::wstring)>(std::bind(&B::foo5, b, std::placeholders::_1)) },
        { 5, L"foo6", std::function<void(void)>(std::bind(&B::foo6, b)) },
        { 6, L"foo7", std::function<double(std::wstring, int)>(std::bind(&B::foo7, b, std::placeholders::_1, std::placeholders::_2)) }
      };

      int nResult = -1;
      std::wstring wstrResult = L"";
      double dResult = 0.0;

  //class A
  nResult = boost::any_cast<std::function<int(void)>>(CallBackItems[0].Func)();
  nResult = boost::any_cast<std::function<int(std::wstring)>>(CallBackItems[1].Func)(L"foo2");
  nResult = boost::any_cast<std::function<int(std::wstring, std::wstring)>>(CallBackItems[2].Func)(L"foo", L"3");
  //class B
  wstrResult = boost::any_cast<std::function<std::wstring(void)>>(CallBackItems[3].Func)();
  wstrResult = boost::any_cast<std::function<std::wstring(std::wstring)>>(CallBackItems[4].Func)(L"foo5");
  boost::any_cast<std::function<void(void)>>(CallBackItems[5].Func)();
  dResult = boost::any_cast<std::function<double(std::wstring, int)>>(CallBackItems[6].Func)(L"foo", 7);

Answer 1

A::foo(1|2|3) 是非静态成员函数，这意味着它们采用隐式第一个参数，指向调用它们的对象实例的指针(this 指针)。您有两个选项可用，要么使用 std::bind 绑定(bind)您要在其上调用成员函数的对象，要么稍后在您 call( ) 它。

我正在用一个可变参数模板版本替换你的两个 call 重载

template<typename Ret, typename... T>
Ret call(const std::string& s, T&&... arg) {
    // we have to assume that our users know what we are actually returning here
    const boost::any& a = calls[s];
    return boost::any_cast< std::function<Ret(T...)> >(a)(std::forward<T>(arg)...);
}

---

选项 1:使用 std::bind

A a;
AnyCaller c;
c.add("foo1", std::function<int()>(std::bind(&A::foo1, &a)));
c.add("foo2", std::function<double(std::wstring)>(
                std::bind(&A::foo2, &a, std::placeholders::_1)));

c.call<int>("foo1");
c.call<double>("foo2", std::wstring(L"Calling foo2"));

---

选项2:调用函数时传递对象指针。请注意，在这种情况下，std::function 的类型不同。

A a;
AnyCaller c;
c.add("foo1", std::function<int(A*)>(&A::foo1));
c.add("foo2", std::function<double(A*, std::wstring)>(&A::foo2));

c.call<int>("foo1", &a);
c.call<double>("foo2", &a, std::wstring(L"Calling foo2"));

第二个选项does not work在 VS2013 上。

Live demo两种选择。