C++模拟委托实现
来源：互联网 发布：怎么学习plc编程 编辑：程序博客网 时间：2024/04/28 13:03
最近这段时间在仿造.net的部分库，写一个小型的C++类库。既然要模仿.net，那么委托是少不了的。
本来想直接使用boost::function, 但他没有实现operator==, 不太好实现多播委托。
boost :: signal 库需要调用编译好的动态库，不符合我的要求，而且他的disconnect的实现让人很不满意，必须把在在调用connect时返回的哪个对象保存起来才能调用disconnect;
没办法，只有仿造function库重新写了一共，好像我考虑的系统只是2000以后的系统，和vc7.0以后的编译器，不用考虑编译器不支持偏特化的问题，今天捣鼓了一天，总算弄出来了
先看看如何使用
class A
{
public:
void operator()(int&)
{
cout<<"A::operator()"<<endl;
}
void fun(int&)
{
cout<<"A::fun"<<endl;
}
};
void fun(int&)
{
cout<<"fun"<<endl;
}
int main()
{
typedef winst::Delegate<void(int&)> Function;
int i = 1;
A a;
Function dop(&a);
Function dmem(&A::fun, &a);
Function dfree(fun);
dop(i);
dmem(i);
dfree(i);
dop += Function::MakeDelegate(fun);
dmem += Function::MakeDelegate(fun);
dop(i);
dmem(i);
cout<< (dop == dmem) <<endl;
cout<< dop.Have(Function::MakeDelegate(fun))<<endl;
dmem -= Function::MakeDelegate(&A::fun, &a);
dmem(i);
}
实现的关键是
class Holder;
class A
{
public:
void fun(){};
};
A a;
Holder* holderPtr reinterpret_cast<Holder*>(&a);
void(Holder::*f)(void) = &A::fun;
(holderPtr->*)()//调用的时a.fun();
当调用a.fun()时，实际上是相当于g_fun(&a)
只要g_fun,和a的地址正确，函数类型和参数类型不重要
这样就可以把函数对象，成员函数，自由函数保存下来
template<typename R>
class DelegateHolder<R(void)>
{
public:
typedef R(MemberFunHolder::* MemberFun)(void);
typedef R(*FreeFun)(void);
typedef DelegateHolder<R(void)> ThisType;
DelegateHolder(FreeFun fun)
{
MemberFun* f = reinterpret_cast<MemberFun*>(&fun);
fun_ = *f;
objPtr_ = 0;
}
template<typename T>
DelegateHolder(R(T::*fun)(void), T* objPtr)
{
objPtr_ = reinterpret_cast<MemberFunHolder*>(objPtr);
fun_ = reinterpret_cast<MemberFun>(fun);
}
template<typename T>
DelegateHolder(T * objPtr)
{
objPtr_ = reinterpret_cast<MemberFunHolder*>(objPtr);
fun_ = reinterpret_cast<MemberFun>(&T::operator());
}
。。。。。。。。
R operator()(void)
{
if(objPtr_ == 0)
{
FreeFun * f = reinterpret_cast<FreeFun*>(&fun_);
FreeFun fun = *f;
return fun();
}
else
{
return (objPtr_->*fun_)();
}
}
。。。。。。。。。。。。。。。
private:
MemberFunHolder * objPtr_;
MemberFun fun_;
};
还有一个问题是
class Arg1{};
class Arg2{};
class Arg3{};
template<typename A1 = Arg1, typename A2 = Arg2, typename A3 = Arg3>
class Test
{
public:
void p(){cout<<"0"<<endl;}
};
template<typename A1>
class Test<A1(void), Arg2, Arg3>
{
public:
void p() {cout<<"1"<<endl;}
};
template<typename A1, typename A2>
class Test<A1(A2)>
{
public:
void p() {cout<<"2"<<endl;}
};
Test<int(int)> t;
t.p(); // 2;
Test(int(void)> t2;
t2.p() //1
这样才能对“不同模板参数个数”的类实现特化。
下面时0参数实现的源码
class MemberFunHolder{};
namespace dele_arg
{
class Arg1{};
class Arg2{};
class Arg3{};
class Arg4{};
class Arg5{};
class Arg6{};
class Arg7{};
class Arg8{};
class Arg9{};
class Arg10{};
}
template<typename R,
typename Arg1 = dele_arg::Arg1,
typename Arg2 = dele_arg::Arg2,
typename Arg3 = dele_arg::Arg3,
typename Arg4 = dele_arg::Arg4,
typename Arg5 = dele_arg::Arg5,
typename Arg6 = dele_arg::Arg6,
typename Arg7 = dele_arg::Arg7,
typename Arg8 = dele_arg::Arg8,
typename Arg9 = dele_arg::Arg9,
typename Arg10 = dele_arg::Arg10
>
class DelegateHolder;
template<typename R,
typename Arg1 = dele_arg::Arg1,
typename Arg2 = dele_arg::Arg2,
typename Arg3 = dele_arg::Arg3,
typename Arg4 = dele_arg::Arg4,
typename Arg5 = dele_arg::Arg5,
typename Arg6 = dele_arg::Arg6,
typename Arg7 = dele_arg::Arg7,
typename Arg8 = dele_arg::Arg8,
typename Arg9 = dele_arg::Arg9,
typename Arg10 = dele_arg::Arg10
>
class Delegate;
template<typename R>
class DelegateHolder<R(void)>
{
public:
typedef R(MemberFunHolder::* MemberFun)(void);
typedef R(*FreeFun)(void);
typedef DelegateHolder<R(void)> ThisType;
DelegateHolder(const ThisType & other)
{
operator= (other);
}
DelegateHolder(FreeFun fun)
{
MemberFun* f = reinterpret_cast<MemberFun*>(&fun);
fun_ = *f;
objPtr_ = 0;
}
template<typename T>
DelegateHolder(R(T::*fun)(void), T* objPtr)
{
objPtr_ = reinterpret_cast<MemberFunHolder*>(objPtr);
fun_ = reinterpret_cast<MemberFun>(fun);
}
template<typename T>
DelegateHolder(T * objPtr)
{
objPtr_ = reinterpret_cast<MemberFunHolder*>(objPtr);
fun_ = reinterpret_cast<MemberFun>(&T::operator());
}
bool operator== (const ThisType & other) const
{
return (objPtr_ == other.objPtr_) && (fun_ == other.fun_);
}
bool operator!= (const ThisType & other) const
{
return ! operator== (other);
}
R operator()(void)
{
if(objPtr_ == 0)
{
FreeFun * f = reinterpret_cast<FreeFun*>(&fun_);
FreeFun fun = *f;
return fun();
}
else
{
return (objPtr_->*fun_)();
}
}
DelegateHolder & operator= (const ThisType & other)
{
objPtr_ = other.objPtr_;
fun_ = other.fun_;
return *this;
}
private:
MemberFunHolder * objPtr_;
MemberFun fun_;
};
template<typename R>
class Delegate<R(void)>
{
typedef DelegateHolder<R(void)> Holder;
typedef R(*FreeFun)(void);
typedef Delegate<R(void)> ThisType;
public:
Delegate(const ThisType& other)
:holder_(other.holder_)
{
}
Delegate(Holder & holder)
:holder_(holder)
{
}
Delegate(FreeFun fun)
:holder_(fun)
{
}
template<typename T>
Delegate(R(T::*fun)(void), T* objPtr)
:holder_(fun, objPtr)
{
}
template<typename T>
Delegate(T * objPtr)
:holder_(objPtr)
{
}
Delegate & operator= (ThisType & other)
{
holder_ = other.holder_;
return *this;
}
Delegate operator= (const Holder & holder)
{
holder_ = holder;
return *this;
}
bool operator== (const ThisType& other) const
{
return holder_ == other.holder_;
}
bool operator != (const ThisType& other) const
{
return ! operator== (other);
}
bool operator== (const Holder & holder) const
{
return holder_ == holder;
}
bool operator!= (const Holder & holder) const
{
return ! operator== (holder)
}
R operator() ()
{
return holder_();
}
private:
Holder holder_;
};
template<>
class Delegate<void(void)>
{
typedef DelegateHolder<void(void)> Holder;
typedef void(*FreeFun)(void);
typedef Delegate<void(void)> ThisType;
public:
Delegate(ThisType & other)
:holderList_(other.holderList_)
{
}
Delegate(Holder& holder)
{
operator+= (holder);
}
Delegate(FreeFun fun)
{
Holder holder(fun);
operator += (holder);
}
template<typename T>
Delegate(void(T::*fun)(void), T* objPtr)
{
Holder holder(fun, objPtr);
operator += (holder);
}
template<typename T>
Delegate(T * objPtr)
{
Holder holder(objPtr);
operator += (holder);
}
void operator += (Holder & holder)
{
if( FindHolder(holder) == false )
{
holderList_.push_back(holder);
}
}
void operator -= (Holder & holder)
{
holderList_.remove(holder);
}
bool operator == (const ThisType & other) const
{
return holderList_ == other.holderList_;
}
bool operator != (const ThisType & other) const
{
return ! operator== (other);
}
bool operator == (const Holder & holder) const
{
if( holderList_.size() != 1 )
{
return false;
}
return FindHolder(holder);
}
bool operator != (const Holder & holder) const
{
return !operator== (holder);
}
bool Have(Holder & holder)
{
return FindHolder(holder);
}
void operator() ()
{
foreach(Holder holder, holderList_)
{
holder();
}
}
public:
static Holder MakeDelegate(FreeFun fun)
{
return Holder(fun);
}
template<typename T>
static Holder MakeDelegate(void(T::*fun)(void), T* objPtr)
{
return Holder(fun, objPtr);
}
template<typename T>
static Holder MakeDelegate(T * objPtr)
{
return Holder(objPtr);
}
private:
bool FindHolder(const Holder & holderFind) const
{
foreach(Holder holder, holderList_)
{
if( holder == holderFind )
{
return true;
}
}
return false;
}
private:
List<Holder> holderList_;
};
最后的工作就是定义一些宏来简化复制过程，然后复制，修改，实现1-10个参数的情况。还有就是要注意对象生存期的问题
- C++模拟委托实现
- [C++]实现委托模型
- [C++]实现委托模型
- [C++]实现委托模型
- [C++]实现委托模型
- [C++]实现委托模型
- [C++]实现委托模型
- [C++]实现委托模型
- [C++]实现委托模型
- [C++]实现委托模型
- C++::模拟实现List
- c++:模拟实现vector
- 【c++】模拟实现堆
- 【C++】模拟实现栈
- 【C++】模拟实现队列
- 《Effective C#》：用委托实现回调
- Objective-C 协议 简介 +委托的实现
- Objective-C 协议 简介 +委托的实现
- 我的问题
- 与bluesen商榷:中文编程--落后的符号系统/社会决定技术先进性，落后不应归咎技术本身,包括人的思想落后
- 我的体会
- Disjoint-set Data Structures
- MyEclipse 6.0 注册码
- C++模拟委托实现
- 昨晚失眠严重
- struts+spring+hibernate基本项目框架的搭建(3)--Struts校验框架的使用
- linux动/静态库的生成和使用
- 关于如何在CString和char*之间转换的一些心得
- "Automation 服务器不能创建对象" 的解决方案
- 配置jboss的oracle数据源
- 第一次在CSDN上作业
- jboss4.2 webogic9.0 下,ejb2.0 实体bean主键的配置
