Question

我制作了包含函数的向量，但它们没有参数列表。而且，他们不在课堂里。我有一个名为Dialog的类，我需要存储具有特定签名的函数指针。这是我对这些函数的typedef：

typedef INT_PTR (*MsgHandler)(WPARAM,LPARAM);

但是，由于包含这些MsgHandler的向量将在我的Dialog类中，我的CMainWnd类将继承该类，当我尝试push_back函数时，函数的签名与MsgHandler的签名不同。这是我的代码，尝试push_back向量中的函数的4种变体，以及每个变量的结果错误：

typedef INT_PTR (*MsgHandler)(WPARAM,LPARAM);

class Dialog
{
protected:
    Dialog(void); // Must be inherited
    vector<MsgHandler> Handlers;
}

class CMainWnd : public Dialog
{
public:
    INT_PTR MyHandler(WPARAM wp, LPARAM lp) {
        return TRUE;
    }

    CMainWnd(void) {
        // Attempt 1: Handlers.push_back(MyHandler);
        // Attempt 2: Handlers.push_back(&MyHandler);
        // Attempt 3: Handlers.push_back(CMainWnd::MyHandler);
        // Attempt 4: Handlers.push_back(&CMainWnd::MyHandler);
    }
};

尝试1会产生以下错误：

error C3867: 'CMainWnd::MyHandler': function call missing argument list; use '&CMainWnd::MyHandler' to create a pointer to member

尝试2收益：

error C2276: '&' : illegal operation on bound member function expression

尝试3收益：

error C3867: 'CMainWnd::MyHandler': function call missing argument list; use '&CMainWnd::MyHandler' to create a pointer to member

尝试4收益：

error C2664: 'std::vector<_Ty>::push_back' : cannot convert parameter 1 from 'INT_PTR (__thiscall CMainWnd::* )(WPARAM,LPARAM)' to 'const MsgHandler &'

我认为尝试4最接近正确，但如前所述，因为该函数是成员，它会改变签名。如何将函数指针存储在继承的类Dialog中定义的向量中：

返回类型为INT_PTR
有两个参数，第一个是WPARAM，第二个是LPARAM
是派生类的成员，其构造是将它们添加到向量

我听说过使用boost::function来做这样的事情，但是我已经查找了它的文档，我不知道如何使用它，这一切似乎让我感到困惑。我非常希望只是将函数添加到向量中，就好像它们是变量而不是使用绑定操作来阻止我的代码，而不是。（可能只是因为我在提升功能时无知）。

我在这里做错了什么，或者我可以使用boost::function来做这件事吗？对于boost::function方式，我尝试将向量声明为vector<boost::function<INT_PTR(WPARAM,LPARAM)>>并尝试向其添加MyHandler，但这不起作用。如果我不需要，我宁愿不使用提升，但如果有人建议这样做的提升方式，请澄清我如何做到这一点？

Answer 1

如果您可以访问C ++ 11，这就是lambdas真正闪耀的地方。我会稍微更改一下你的代码，因为它让我的代码变得更容易，但是你应该能够很容易地为你的需求修复它：

#include <vector>
#include <functional>
#include <iostream>

class Dialog
{
protected:
    Dialog() { } // Must be inherited
    std::vector<std::function<bool (int, int)>> Handlers;
};

class CMainWnd : public Dialog
{
public:
    bool MyHandler(int wp, int lp) 
    {
        std::cout << "(" << wp << ", " << lp << ")\n";
        return true;
    }

    CMainWnd() 
    {
       Handlers.push_back([this](int wp, int lp) -> bool { return this->MyHandler(wp, lp); });
       std::cout << Handlers[0](1,1) << "\n";
    }
};

int main()
{
    CMainWnd c;
    return 0;
}

编辑：当使用C ++ 03并改为提升时：

#include <boost/function.hpp>
#include <boost/bind.hpp>

class Dialog
{
protected:
    Dialog() { } // Must be inherited
    std::vector<boost::function<bool (int, int)> > Handlers;
};

class CMainWnd : public Dialog
{
public:
    bool MyHandler(int wp, int lp) 
    {
        std::cout << "(" << wp << ", " << lp << ")\n";
        return true;
    }

    CMainWnd() 
    {
       Handlers.push_back(boost::bind(&CMainWnd::MyHandler, this, _1, _2));
       std::cout << Handlers[0](1,1) << "\n";
    }
};

Answer 2

想一想：当你创建一个函数指针向量时，向量的每个元素的大小是多少？没错，函数指针的大小。现在，你怎么能指望它保存指向函数的指针以及指向对象的指针，在该对象上应该调用该函数？

C ++语言功能是围绕“付费使用”原则设计的。所以函数指针尽可能轻。现在，你想要的实际上是代表。代理不是C ++中的语言功能，因此，无论您是否喜欢它，您都需要使用boost :: function（或自己编写）。顺便提一下，比boost :: function有更快的委托解决方案，你可以检查：this code project和this one

以下是使用boost :: function：

的方法

#include <vector>
using namespace std;
#include <boost/function.hpp>
#include <boost/bind.hpp>

typedef int INT_PTR;
typedef int WPARAM;
typedef int LPARAM;

//typedef INT_PTR (*MsgHandler)(WPARAM,LPARAM);
typedef boost::function<INT_PTR(WPARAM,LPARAM)> MsgHandler;

class Dialog
{
protected:
    Dialog(void){} // Must be inherited
    vector<MsgHandler> Handlers;
};

class CMainWnd : public Dialog
{
public:
    INT_PTR MyHandler(WPARAM wp, LPARAM lp) {
        return true;
    }

    CMainWnd(void) {
        // Attempt 1: Handlers.push_back(MyHandler);
        // Attempt 2: Handlers.push_back(&MyHandler);
        // Attempt 3: Handlers.push_back(CMainWnd::MyHandler);
        // Attempt 4: Handlers.push_back(&CMainWnd::MyHandler);
    Handlers.push_back(boost::bind(&CMainWnd::MyHandler, this, _1,_2));
    }
};

int main() {
    CMainWnd w;

}

这里有不可思议的快速代表:(当然正确设置包含路径）

#include <vector>
using namespace std;
#define SRUTIL_DELEGATE_PREFERRED_SYNTAX
#include <srutil/delegate/delegate.hpp>

typedef int INT_PTR;
typedef int WPARAM;
typedef int LPARAM;

typedef srutil::delegate<INT_PTR(WPARAM,LPARAM)> MsgHandler;

class Dialog
{
protected:
    Dialog(void){} // Must be inherited
    vector<MsgHandler> Handlers;
};

class CMainWnd : public Dialog
{
public:
    INT_PTR MyHandler(WPARAM wp, LPARAM lp) {
        return true;
    }

    CMainWnd(void) {
    Handlers.push_back(MsgHandler::from_method<CMainWnd, 
              &CMainWnd::MyHandler>(this));
    }
};

int main() {
    CMainWnd w; 
}

Answer 3

在C ++中，您通常使用std::function或其等效增强。然而，在某些情况下可能适合的C风格解决方案 - 存储并将其他用户数据传递给函数。

typedef INT_PTR (*MsgHandlerFn)(WPARAM,LPARAM, void*);
struct MsgHandler
{
   MsgHandler( 
     MsgHandlerFn in_fn,
     void * in_user_data )
   : fn(in_fn), user_data(in_user_data)
   {}
   //TODO: Add copy constructor, assignment operator, default constructor
   MshHandlerFn fn;
   void * user_data;
};

class Dialog
{
protected:
    Dialog(void); // Must be inherited
    vector<MsgHandler> Handlers;
};

class CMainWnd : public Dialog
{
  public:
    INT_PTR MyHandler(WPARAM wp, LPARAM lp) {
        return TRUE;
    }
  protected:
    static INT_PTR MyHandlerStatic(WPARAM wp, LPARAM lp, void * user_data)
    {
       return static_cast<CMainWnd*>(user_data)->MyHandler(wp,lp);
    }
  public:
    CMainWnd(void) {
      Handlers.push_back( MsgHandler( &CMainWnd::MyHandlerStatic, this ) );
     }
};

现在，对话框调用处理程序的循环需要看起来更像这个

for( unsigned int i=0; i<Handlers.size(); ++i)
   Handlers[i].fn( wp,lp, Handlers[i].user_data);

Answer 4

以下webpage描述了您的问题。

类成员函数是Just Not normal函数。如果声明一个正常的函数对你来说没问题（在例子中似乎没问题），就这样做吧。

是派生类的成员，其构造是将它们添加到向量
的构造

如果你真的需要，你可以使用c函数指针来创建你的类的函数成员。我不知道你是否可以在类声明范围中声明非成员函数成员函数，如果可以，可以这样做。

祝你好运

矢量功能与参数

4 个答案: