C++ 将boost:：bind函数传递给内部类时出错

我以前曾设法将boost:：bind函数存储在变量中，以便以后根据需要调用该函数。这非常简单，您只需执行以下操作：

//Caller, note the Accepthandler function is specified here
mysocket->RegisterAcceptHandler(boost::bind(&AcceptHandler,_1,_2));

//Registration function, a member of the socket class. cnctCallBack is a typedef to a boost:function
void mynamespace::socket::RegisterAcceptHandler( const cnctCallBack &cb )
{
    connectCallBack = cb;
}

并使用适当的参数调用connectCallBack

我的问题是，我现在希望处理程序在内部成员对象中注册函数。换句话说，socket将不再调用回调，而是告诉一个内部类回调，它将调用回调。您可能认为可以简单地将&cb分配给内部类中的函数，但事实并非如此：

typedef boost::function<void()> recCB;

class InnerClass{

public:
    void AttachListener(const recCB &rcb);
    void RunListener();

private:
    boost::function<void()> callback;
};
void InnerClass::AttachListener( const boost::function<void()> &rcb )
{
    callback = rcb;
}

void InnerClass::RunListener()
{
    callback();
}

class OuterClass{

public:
    void AttachListener(const boost::function<void()> &rcb);
    void RunListener();

private:
    InnerClass * ic;
    boost::function<void()> cb;
};

void OuterClass::AttachListener( const boost::function<void()> &rcb )
{
    cb = rcb;
    ic->AttachListener(rcb);
}

void OuterClass::RunListener()
{   
    cb();
    ic->RunListener();
}

typedef boost:：函数recCB；
类内部类{
公众：
无效附件列表器（施工记录和rcb）；
void RunListener（）；
私人：
boost：：函数回调；
};
void InnerClass:：AttachListener（常量boost:：函数和rcb）
{
回调=rcb；
}
void InnerClass:：RunListener（）
{
回调（）；
}
类外类{
公众：
void AttachListener（const boost:：function和rcb）；
void RunListener（）；
私人：
内部类*ic；
boost：：函数cb；
};
void OuterClass:：AttachListener（常量boost:：函数和rcb）
{
cb=rcb；
ic->附件列表器（rcb）；
}
void OuterClass:：RunListener（）
{   
cb（）；
ic->RunListener（）；
}

事实证明，当我运行outerclass并尝试使用outerclass.AttachListener分配函数时，它在0xfffff…（这是一个相当明显的地址）处给我一个访问冲突。查看调用堆栈，有关赋值运算符的某些内容导致了问题，但我看不出问题出在哪里。当赋值给外部类中的变量时，很容易检查相同的赋值代码是否有效。我想知道这是否意味着你只能在一个层次上做到这一点

void OuterClass::AttachListener( const boost::function<void()> &rcb )
{
    cb = rcb;
    ic->AttachListener(rcb); //<------the problem is here
}

它是非指针成员，并将其用作：

void OuterClass::AttachListener( const boost::function<void()> &rcb )
{
    cb = rcb;
    ic.AttachListener(rcb);
}

void OuterClass:：AttachListener（const boost:：function&rcb）
{
cb=rcb；
ic.附件列表器（rcb）；
}

那好多了

它是非指针成员，并将其用作：

void OuterClass::AttachListener( const boost::function<void()> &rcb )
{
    cb = rcb;
    ic.AttachListener(rcb);
}

void OuterClass:：AttachListener（const boost:：function&rcb）
{
cb=rcb；
ic.附件列表器（rcb）；
}

---

那好多了。

哦，天哪，我真不敢相信我竟然没有想到这一点。它只适用于一个简单的ic=new InnerClass（）。“我现在要去睡觉了，感觉自己有点迟钝了。”@Carlos:但别这么做。按照我在回答中的建议去做，除非你真的需要指针，在这种情况下，你应该使用

std:：unique_ptr

或

std:：shared_ptr

，以适合你的需要为准。是的，我理解共享指针之类的概念。最好不要允许内存泄漏的可能性。我只是创建了一个测试用例，看看到底是什么在破坏。哦，天哪，我真不敢相信我没有想到这一点。它只适用于一个简单的ic=new InnerClass（）。“我现在要去睡觉了，感觉自己有点迟钝了。”@Carlos:但别这么做。按照我在回答中的建议去做，除非你真的需要指针，在这种情况下，你应该使用

std:：unique_ptr

或

std:：shared_ptr

，以适合你的需要为准。是的，我理解共享指针之类的概念。最好不要允许内存泄漏的可能性。我只是创建了一个测试用例，看看到底是什么在破坏。