C++ C++；函子与零

首先是免责声明，我将替换一组使用boost:：function和boost:：bind的代码。然而，我正在转向一个不允许rtti的代码库。我想继续使用boost，但不知道是否有办法绕过这个限制

因此，我试图模仿它的一些功能，但要简单得多。我有一个回调类：

   template <class Class, typename ReturnType = void> class Callback0 {
   typedef ReturnType (Class::*Method)();

   public:
       Callback0(Class* object, Method method)
           : m_object(object)
           , m_method(method)
       {
          ;
       }

       Callback0(const Callback0& callback)
           : m_object(callback.m_object)
           , m_method(callback.m_method)
       {
          ;
       }

       operator bool() {
           return m_object != 0;
       }

       operator bool() const {
           return m_object != 0;
       }

       ReturnType operator()() {
           return (m_object->*m_method)();
       }

       Callback0<Class, ReturnType>& operator=(const Callback0<Class, ReturnType>& callback) {
           if(this != &callback) {
               m_object = callback.m_object;
               m_method = callback.m_method;
           }

           return *this;
       }

   private:
       Class*   m_object;
       Method   m_method;
};

模板类回调0{
typedef ReturnType（类：：*方法）（）；
公众：
回调0（类*对象，方法）
：m_对象（对象）
，m_法（method）
{
;
}
Callback0（常量Callback0和callback）
：m_对象（callback.m_对象）
，m_方法（callback.m_方法）
{
;
}
运算符bool（）{
返回m_对象！=0；
}
运算符bool（）常量{
返回m_对象！=0；
}
ReturnType运算符（）（）{
返回（m_对象->*m_方法）（）；
}
Callback0&operator=（const Callback0&callback）{
如果（此！=&回调）{
m_object=callback.m_object；
m_方法=callback.m_方法；
}
归还*这个；
}
私人：
类*m_对象；
方法m_法；
};

这允许我使用零参数执行简单回调：

class Meh {
    public:
        Meh() {;}
        ~Meh() {;}

        void f0() {
            footprint6v("%s\n", __FUNCTION__);
        }
};


static void meh() {
    Meh* m = new Meh;

    Callback0<Meh, void> c0(m, &Meh::f0);

    c0();
}

Meh类{
公众：
Meh（）{；}
~Meh（）{；}
void f0（）{
封装外形6V（“%s\n”，函数）；
}
};
静态空隙meh（）{
Meh*m=新Meh；
回调0 c0（m和Meh:：f0）；
c0（）；
}

我希望能够将回调对象作为默认参数指定为零，如下所示：

class Wtf {
    public:
        Wtf() : m_callback(0) {;}
        ~Wtf() {;}

        void doSomething(const Callback0<Wtf, void>& callback = 0) {
            m_callback = callback;
        }

    private:
        Callback0<Wtf, void> m_callback;
};

class-Wtf{
公众：
Wtf（）：m_回调（0）{；}
~Wtf（）{；}
void doSomething（const Callback0&callback=0）{
m_callback=回调；
}
私人：
回调0 m_回调；
};

这在使用boost:：function时起作用，您可以这样做：

class Wtf {
    public:
        Wtf() : m_callback(0) {;}
        ~Wtf() {;}

        void doSomething(const boost::function<void()>& callback = 0) {
            m_callback = callback;
        }

    private:
        boost::function<void()> m_callback;
};

class-Wtf{
公众：
Wtf（）：m_回调（0）{；}
~Wtf（）{；}
void doSomething（const boost:：function&callback=0）{
m_callback=回调；
}
私人：
boost：：函数m_回调；
};

---

我想boost在这里变魔术了。我知道我可以将参数更改为指针而不是引用，但正如我所说的，我正在替换大量代码，并希望将更改boost的影响降至最低。

boost并没有发挥任何神奇的作用。0只是函数指针构造函数的空函数指针

我建议您只提供一个默认构造函数

Callback0() : m_object(NULL), m_method(NULL) {}

让某些东西看起来像

void doSomething(const Callback0<Wtf, void>& callback = Callback0<Wtf, void>()) {

void doSomething（const Callback0&callback=Callback0（））{

Boost没有做任何神奇的事情。0只是函数指针构造函数的空函数指针

我建议您只提供一个默认构造函数

Callback0() : m_object(NULL), m_method(NULL) {}

让某些东西看起来像

void doSomething(const Callback0<Wtf, void>& callback = Callback0<Wtf, void>()) {

void doSomething（const Callback0&callback=Callback0（））{

谢谢Logan。当我得到你的答案时，我突然意识到这是一个相当愚蠢的问题，答案很简单。我最终创建了一个构造函数，它使用整数参数来避免在函数原型中显式调用默认构造函数。如果你认为他的答案是正确的，你应该将其标记为正确的，这样他就可以修改t代表。谢谢Logan。当我得到你的答案时，我突然意识到这是一个相当愚蠢的问题，答案很简单。我最终创建了一个构造函数，它使用整数参数来避免在函数原型中显式调用默认构造函数。如果你认为他的答案是正确的，你应该将其标记为正确的，所以他可以得到代表。”…不允许rtti。“看起来相当严厉和武断。你能澄清一下这个限制背后的原因吗？如果这是一个风格指导原则的问题，那么我不确定任何外国依赖的任何部分都能完全符合内部风格指导原则，但这不是拒绝外部依赖的理由，只要你在指导原则范围内使用它。但是，如果你正在编译的编译器根本不支持C++的那部分，那么这是另一回事了。谢谢你的评论。我的意思是，这个项目是用-fNORTRTI旗标编译的。因此，没有RTTI。“……不允许RTTI。”看起来相当严厉和武断。你能澄清一下这个限制背后的原因吗？如果这是一个风格指导原则的问题，那么我不确定任何外国依赖的任何部分都能完全符合内部风格指导原则，但这不是拒绝外部依赖的理由，只要你在指导原则范围内使用它。但是，如果你正在编译的编译器根本不支持C++的那部分，那么这是另外一回事了。谢谢你的评论。我的意思是，这个项目是用-fNORTRTI标志编译的，所以没有RTTI。