C++实现的委托机制（二）

最新推荐文章于 2024-09-12 11:04:16 发布
最新推荐文章于 2024-09-12 11:04:16 发布
阅读量72 收藏
点赞数
文章标签： c/c++
原文链接：http://www.cnblogs.com/happyblog/archive/2011/10/03/2198358.html
版权

C++实现的委托机制（二）

作者：gouki04(啊古)  撰写日期：2011-09-27

博客链接：http://blog.csdn.net/gouki04

1.实现任意参数的函数委托

    按上一篇文章的方法，你已经可以使用无参数的函数委托了。当然，这远远不够。要实现任意参数的函数委托，这里的任意参数包括任意个数和任意类型。任意类型这个容易解决，使用模板就行，但任意参数个数呢？

    注：最终的实现代码可以在这里下载：http://download.csdn.net/detail/gouki04/3641328

    只能不同个数各实现一个类，如：

// 单参函数委托
template<typename TP1>
class CMultiDelegate1{};

// 双参函数委托
template<typename TP1, typename TP2>
class CMultiDelegate2{};

    注意类名是不一样的，分别为CMultiDelegate1和CMultiDelegate2。C++里面，类名相同但模板参数个数不同是会当成一个类对待的，所以那样编译不过的，这样是不是很麻烦呢？

    不是很麻烦，是相当麻烦。因为不单单是CMultiDelegate要实现多个参数的版本。连IDelegate、CStaticDelegate和CMethodDelegate都要实现对应的多个参数的版本！其实所有版本的内部实现几乎一样，下面给出双参函数的版本：

template<typename TP1, typename TP2>
class IDelegate2
{
public:
virtual ~IDelegate2() { }
virtual bool isType( const std::type_info& _type) = 0;
virtual void invoke( TP1 p1, TP2 p2 ) = 0;
virtual bool compare( IDelegate2<typename TP1, typename TP2> *_delegate) const = 0;
};

template<typename TP1, typename TP2>
class CStaticDelegate2 : public  IDelegate2<typename TP1, typename TP2>
{
public:
    typedef void (*Func)( TP1 p1, TP2 p2 );

    CStaticDelegate2 (Func _func) : mFunc(_func) { }

virtual bool isType( const std::type_info& _type) { return typeid( CStaticDelegate2<typename TP1, typename TP2> ) == _type; }

virtual void invoke( TP1 p1, TP2 p2 )
    {
        mFunc( p1, p2 );
    }

virtual bool compare( IDelegate2<typename TP1, typename TP2> *_delegate) const
    {
if (0 == _delegate || !_delegate->isType(typeid(CStaticDelegate2 <typename TP1, typename TP2>)) ) return false;
        CStaticDelegate2 <typename TP1, typename TP2> * cast = static_cast<CStaticDelegate2 <typename TP1, typename TP2> *>(_delegate);
return cast->mFunc == mFunc;
    }
virtual bool compare(IDelegateUnlink * _unlink) const { return false; }

private:
    Func mFunc;
};

template <typename T, typename TP1, typename TP2>
class CMethodDelegate2 : public  IDelegate2 <typename TP1, typename TP2>
{
public:
    typedef void (T::*Method)( TP1 p1, TP2 p2 );

    CMethodDelegate2(T * _object, Method _method) : mObject(_object), mMethod(_method) { }

virtual bool isType( const std::type_info& _type) { return typeid( CMethodDelegate2 <T, TP1, TP2> ) == _type; }

virtual void invoke( TP1 p1, TP2 p2 )
    {
        (mObject->*mMethod)( p1, p2 );
    }

virtual bool compare(  IDelegate2 <typename TP1, typename TP2>  * _delegate) const
    {
if (0 == _delegate || !_delegate->isType(typeid(CMethodDelegate2 <T, TP1, TP2>)) ) return false;
        CMethodDelegate2 <T, TP1, TP2>  * cast = static_cast<  CMethodDelegate2 <T, TP1, TP2>  * >(_delegate);
return cast->mObject == mObject && cast->mMethod == mMethod;
    }

private:
    T * mObject;
    Method mMethod;
};

template   <typename TP1, typename TP2>
inline  delegates::IDelegate2 <typename TP1, typename TP2>  * newDelegate( void (*_func)( TP1 p1, TP2 p2 ) )
{
return new delegates::CStaticDelegate2 <typename TP1, typename TP2>  (_func);
}

template <typename T, typename TP1, typename TP2>
inline  delegates::IDelegate2 <typename TP1, typename TP2>  * newDelegate( T * _object, void (T::*_method)( TP1 p1, TP2 p2 ) )
{
return new delegates::CMethodDelegate2  <T, TP1, TP2>  (_object, _method);
}

template   <typename TP1, typename TP2>
class CMultiDelegate2
{
public:
    typedef IDelegate2 <typename TP1, typename TP2>  IDelegate;
    typedef typename std::list<IDelegate*> ListDelegate;
    typedef typename ListDelegate::iterator ListDelegateIterator;
    typedef typename ListDelegate::const_iterator ConstListDelegateIterator;

    CMultiDelegate2 () { }
    ~CMultiDelegate2 () { clear(); }

bool empty() const
    {
for (ConstListDelegateIterator iter = mListDelegates.begin(); iter!=mListDelegates.end(); ++iter)
        {
if (*iter) return false;
        }
return true;
    }

void clear()
    {
for (ListDelegateIterator iter=mListDelegates.begin(); iter!=mListDelegates.end(); ++iter)
        {
if (*iter)
            {
                delete (*iter);
                (*iter) = 0;
            }
        }
    }

    CMultiDelegate2  <typename TP1, typename TP2> & operator+=(IDelegate* _delegate)
    {
for (ListDelegateIterator iter=mListDelegates.begin(); iter!=mListDelegates.end(); ++iter)
        {
if ((*iter) && (*iter)->compare(_delegate))
            {
                delete _delegate;
return *this;
//MYGUI_ASSERT(false, "dublicate delegate");
            }
        }
        mListDelegates.push_back(_delegate);
return *this;
    }

    CMultiDelegate2  <typename TP1, typename TP2> & operator-=(IDelegate* _delegate)
    {
for (ListDelegateIterator iter=mListDelegates.begin(); iter!=mListDelegates.end(); ++iter)
        {
if ((*iter) && (*iter)->compare(_delegate))
            {
if ((*iter) != _delegate) delete (*iter);
                (*iter) = 0;
break;
            }
        }
        delete _delegate;
return *this;
    }

void operator()( TP1 p1, TP2 p2 )
    {
        ListDelegateIterator iter = mListDelegates.begin();
while (iter != mListDelegates.end())
        {
if (0 == (*iter))
            {
                iter = mListDelegates.erase(iter);
            }
else
            {
                (*iter)->invoke( p1, p2 );
                ++iter;
            }
        }
    }

private:
    CMultiDelegate2 (const CMultiDelegate2  <typename TP1, typename TP2> & _event);
    CMultiDelegate2<typename TP1, typename TP2> & operator=(const CMultiDelegate2<typename TP1, typename TP2> & _event);

private:
    ListDelegate mListDelegates;
};

    当然放心啦，不会让大家将不同参数的版本各写一遍的。下面要介绍的是MyGUI的解决方法，一个利用预编译和头文件重复编译的方法（很有意思的）。我们一般写头文件时，都会加上防止头文件重复编译的代码，如：

#ifndef __XXX_H__
#define __XXX_H__

// ..类声明等

#endif

    这里我们就要反其道而行，去掉防止重复编译的代码，然后重复包含这个头文件，但每次其编译的都是不同参数个数的版本。第一次编译的是无参的，第二次是单参的，第三次是双参.....一直到你想要支持的参数个数。那怎么让其每次编译的都不同呢？答案就是使用强大的预编译：宏！下面给出单参的IDelegate的例子：

//首先定义以下宏
#define DELEGATE_TEMPLATE template
#define DELEGATE_TEMPLATE_PARAMS <typename TP1>
#define DELEGATE_TEMPLATE_ARGS TP1 p1
#define MYGUI_I_DELEGATE IDelegate1

    那么下面这段代码就会编译出单参的IDelegate版本：

DELEGATE_TEMPLATE   DELEGATE_TEMPLATE_PARAMS
class MYGUI_I_DELEGATE
{
public:
virtual ~MYGUI_I_DELEGATE() { }
virtual bool isType( const std::type_info& _type) = 0;
virtual void invoke( DELEGATE_PARAMS ) = 0;
virtual bool compare( MYGUI_I_DELEGATE DELEGATE_TEMPLATE_ARGS  * _delegate) const = 0;
};

    神奇吧，这里使用的可以说是宏实现的多态。在这段代码编译完了之后，将所有宏都undefine掉，如：

#undef DELEGATE_TEMPLATE
#undef DELEGATE_TEMPLATE_PARAMS
#undef DELEGATE_TEMPLATE_ARGS
#undef MYGUI_I_DELEGATE
//再重新定义双参版本的，如
#define DELEGATE_TEMPLATE template
#define DELEGATE_TEMPLATE_PARAMS <typename TP1, typename TP2>
#define DELEGATE_TEMPLATE_ARGS TP1 p1, TP2 p2
#define MYGUI_I_DELEGATE IDelegate2

    那么编译出来的就是双参的版本了！使用这种方法就可以将其他的如CStaticDelegate、CMethodDelegate和CMultiDelegate的各种版本都实现了，而你要做的仅是重新define下那些宏就行了，够方便了吧。

    下一篇文章将会介绍MyGUI实现的一些辅助类，如单委托和DelegateUnlink。并给出一个测试例子，测试该委托机制对C++各种函数的支持。

转载于:https://www.cnblogs.com/happyblog/archive/2011/10/03/2198358.html

weixin_30695195
关注
C++实现委托机制(二)
YzlCoder的记事本
05-15 7921
上一篇文章已经介绍了如何构建一个无参数无返回值的函数指针的委托,这篇文章将对上一文章所述委托进行扩展，使得可以注册任意函数指针，不过再讲篇内容之前先要介绍一下实现这个功能所需要了解的C++11的一个新特性———可变参数模板。
C++实现的委托机制(2)
古的博客
10-08 2125
C++实现的委托机制(2) 1.实现任意参数的函数委托 按上一篇文章的方法，你已经可以使用无参数的函数委托了。当然，这远远不够。要实现任意参数的函数委托，这里的任意参数包括任意个数和任意类型。任意类型这个容易解决，使用模板就行，但任意参数个数呢？ 注：最终的实现代码可以
C++实现委托机制之完整代码实现(二)
起个名字好难啊
05-02 451
头文件 MyDelegate.h 代码如下： #include #include #include template class IDelegate { public: IDelegate(){} virtual ~IDelegate(){} virtual bool isType(const std::type_info& _type) = 0; virtual ReturnTy
关于c++委托机制的实现（二）
qq_34236354的博客
05-06 168
写自己的bug，让自己无bug可写 上一篇博客地址：https://blog.csdn.net/qq_34236354/article/details/89876304，有兴趣的可以去看看 下一篇博客地址：https://blog.csdn.net/qq_34236354/article/details/89881722，有兴趣的可以去看看 函数简介：c++中有普通函数，类静态成员函数，类普...
C++实现委托机制(一)
热门推荐
YzlCoder的记事本
05-14 2万+
如果你接触过C#,你就会觉得C#中的delegate(委托)十分灵巧，它的用法上和C\C++的函数指针很像，但是却又比C\C++的函数指针更加灵活。并且委托可以一对多，也就是可以注册多个函数，甚至是某个类的非静态成员函数。而实现事件消息机制【1】也十分依赖于委托机制。基于这样的目的，我们试着在C++上封装出这样的一个委托机制。
C++：实现委托机制
Taopper的博客
08-17 762
为了解决GUI 跨线程操作界面的导致主线程崩溃的情况, C++ 11 终于推出了自己的thread 类thread 类提供detach() 的方法, 让worker线程也具备了操作GUI的能力.在GUI开发中, 通过使用function和thread等C++ 11 新特性,能够更便捷的开发出高质量的程序, 同时回避开发过程中的问题。...
在C++实现委托
七彩狻猊
05-09 1930
<br />在前面提到回调了，那么现在就开始说委托吧。个人是这么理解委托的，就是一件事你不做或者不能做或者不想做，那么就委托给别人做，我只调用别人的函数接口就可以了，也就是我要实现一个功能，我只要接口，实际的实现委托给别人，突然有一天我要做的事的逻辑发生了变化，那么我也不需要更改自己的调用，只需要被委托者更换一下逻辑就可以了。同时，如果在一定的场合下要调用很多相同形式的函数，那么使用委托将很方便。<br />在设计模式中状态模式、策略模式、访问者模式本质上是在更特殊的场合采用了委托模式。委托也可以接受多个实
C++ - 使用标准库实现事件和委托，信号和槽机制
10-17
在C++编程中，事件和委托是用于对象间通信的重要机制。它们通常被用来实现响应式编程，使得当一个对象的状态发生改变时，其他对象能够自动接收到通知并执行相应的操作。这种机制在图形用户界面（GUI）开发、并发编程...
c++实现委托
05-29
以下我们将详细讨论如何在C++中实现委托，以及给定文件中的相关知识点。 首先，`Hopter.cpp`可能是实现委托的一个实例，可能包含了一个类或多个类，这些类通过成员函数或静态函数来处理委托行为。`memfuntest.cpp`...
C++11 function 委托机制 观察者模式，适用于界面开发，lambda表达式
03-22
在C++编程中，函数委托（Function Delegate）是一种机制，允许我们将一个函数或者函数对象绑定到另一个函数，形成一种回调的方式。C++11引入了委托的概念，这大大增强了C++的灵活性，尤其是在处理事件驱动编程和设计...
C++实现委托及分析
12-22
近对编程语言的委托机制产生了浓厚的兴趣，C#，Objective-c的委托机制已经是各自强有力的编程规范工具，以下文字和代码是我近日对委托机制的理解，不妥之处，请及时指出。 　自我感觉C#的委托针对的对象是函数，...
C语言初阶 --- ⾃定义类型：结构体
2301_79842589的博客
09-08 1040
💫往期文章👇：
从C到C++
D1557329860的博客
09-08 1156
string不是C++的基本数据类型，它是一个C++标准库中的字符串类，使用时需要引入对应的头文件，#include<string>，而不是string.h.引用参数，在不参与计算的情况下，我们建议使用const进行修饰，以达到引用的安全性。声明引用的时候，初始化的值可以是纯数值，但是此时需要使用const关键字修饰，表示该引用为常量引用，这样引用的值不可变。写一个函数，函数有两个参数a和b，函数的功能是交换两个传入的参数原来变量的值。可以使用const修饰引用，此时如果原变量的值改变，引用的值也改变。
C/C++ 趣味代码目录
m0_53061304的博客
09-09 186
0-100行练手 C++实现线性拟合 C++控制台井字棋 C++实现在控制台输出红色爱心 C语言实现三角定位 C++彩色星空 C++实现二叉树 C++ 纳秒级计时器 C++代码：简单的神经元实现 C 语言实现一个循环队列 C++代码：弹力小球 C++代码：矩阵的加减乘运算 C++中的数制转换工具 使用C++实现表达式求值器 C++实现雪花飘落效果 可视化冒泡排序 C++实现简单的内存池 100-300行 C++贪吃蛇 C++ 小球打砖块 C++ 实现K-means算法
C++学习，继承
最新发布
五味香的专栏
09-12 274
C++一个重要概念继承，继承依据一个类来定义另一个类，这样就重用了代码功能和提高执行效率。创建一个类时，不需要完全重新编写新的数据成员和成员函数，只需指定新建的类继承了一个已有的类的成员即可。已有类为，新建类为，一个类可以派生自多个类，它可以从多个基类继承数据和函数。class 基类名 {// 基类的成员class 派生类名 :基类名 {// 派生类的成员，可以是:public：公有继承，基类的公有成员和保护成员在派生类中保持原有访问级别（公有和保护），私有成员不可访问。
【项目二】C++高性能服务器开发——日志系统(日志器，日志级别，日志事件)
weixin_45962681的博客
09-06 220
其实也没啥。
C++ 音频
JackerCSDN的博客
09-09 606
acc流
44. 数字序列中某一位的数字
qq_42889517的博客
09-06 1049
的格式序列化到一个字符序列中。在这个序列中，第5位（从下标0开始计数）是5，第13位是1，第19位是4，等等。对应的是当前位数的哪一个数字，然后计算出是该数字的第几位，从而得到该位上的数字。对应的数字在当前位数的数字范围内，此时可以计算出对应的数字。请写一个函数，求任意第n位对应的数字。表示当前位数的数字的总数，初始时。表示当前数字的位数，用。具体做法是，首先计算出。
C++实现C#委托机制
06-10
以下是一个简单的 C++ 示例代码，演示了如何通过函数指针和对象指针来实现委托机制： ```cpp #include #include using namespace std; class Delegate { public: void (*func)(void*); // 函数指针 void* obj...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值