今天没加班,好吧,那我们继续,上一讲我们说了Connect的声明原型,这一讲我们来看如何实现这个函数,从参数中其实我们大概可以推断出Connect的实现应该和第三个参数有关,这里我们再来回顾一下上一讲我们的声明式:
template<class T,class…Args>
void Connect(
const MString&
funName,
// 作为信号触发的函数名
void(T::*fun1)(Args…),
// funName对应的函数指针
T* obj1,
// 持有函数名为funName的对象
std::function<void(Args…)>eventfun
// 函数对象
)
其实从注释里面几乎可以肯定重点在于obj1本身,因为前面三个参数都是相关联的,而第四个是一个function(关于function到底是什么我没记错的话好像我们在前面的章节中有说过),而第四个参数所带来的灵活性就是无节操的无限制。说到这里,那么问题来了,Connect要如何做才能将这些杂乱的东西联系在一起呢?
我们先设想一种模型:obj1存储一张表,这张表记录他自身函数和槽函数相关联的信息(可以想象一下虚函数的派发原理,当然我们这个可没那个复杂)。ok,现在剩下的就是如何实现这张表了,map似乎可以满足我们的需求,这个关系也很简单,只需要将函数名作为key,将槽函数作为value来储存。这实现起来还是相对简单的,但是缺点是不支持重载函数,如果是Qt的信号槽就不存在这个问题,但是前提是得声明各种各样的信号。
怎么声明这个map呢???向下面这么干么?
template<class R,class…Args>
using AnyFun = std::function<R(Args…)>;
std::map<MString,AnyFun>
mPropretyChangedFunMap;
知道这为什么不行吗?因为AnyFun本身依然还是模板,依然还是需要进行实例化才能够使用,所以上面的声明是不对的,那么,既然不能这么干,那么是不是可以考虑另辟蹊径了呢?前提首先要明白一点关键的地方在AnyFun上面而不是map上面,使用map来储存这个关系是没问题(如果我们想要支持重载函数的话那么可能要考虑multmap了),嗯,std::map<MString,void*>是不是可以呢?但是当回调的时候如何还原到函数类型呢?好吧,我们这里就不纠结,至少到这一步已经离成功不远了。
在我的工具库里面有一个MAny的东西,他能够储存任意类型的对象同时还能够还原对象的原型,这就是我们想要的,boost里面也有一个any(话说当初写这个MAny的时候也参考了boost的any,之所以没有使用boost的any主要是想让自己的东西依赖更少),所以我们可以这样声明map:
std::map<MString,MAny>
mPerpertChangedFunMap;
此处,距离成功80%。接下来要做的事就是将响应槽函数和函数名关联起来:
void BindPropertChangedFun(const MString&
funName,const MAny&
fun){
mPerpertChangedFunMap[funName] = fun;
}
该是时候实现Connect了。
template<class T,class…Args>
static
void Connect(
const MString&
funName,
void(T::*fun1)(Args…),
T* obj1,
std::function<void(Args…)>eventfun
)
{
(obj->BindPropertChangedFun)(funName,eventfun);
}
从这个实现我们看出来那个函数指针似乎没什么用啊,也不知道当初脑子是怎么想的,好吧,先不管,好吧,现在我们已经将这种关系联系在一起,但是任务仅仅完成了三分之一。接下来要做的事就是我们如何让被关联的槽对象被执行。让完成这个过程那么应该有一个通知的动作,而这个通知的动作应该要知道是什么样的类型函数被调用,同时还要知道当前调用的函数的函数名,还能够传递参数,从这些信息中可以简单的推断出来这个通知函数的原型:
template<class T,class…Args>
void NotifyPropertyChanged(
const MString&
funName,
void(T::*func)(Args…),
Args…agrs
);
这个函数的调用也相当的复杂,声明也挺吓人,好吧,我们简化一下调用操作,比如如下:
NotifyPropertyChanged<TestA, const MString&
>(
MPropertyNotifer(TestA, SetValue),
value);
这样一来不至于在参数里面输入一个字符串那么突兀的吓人,这样一来还能够在编译器对参数进行检测,那么MPropertyNotifer又是什么呢?应该想起来了,和MSIGNAL一样同样是一个宏定义:
#ifndef MPropertyNotifer
#define MPropertyNotifer(className,memFun)
#memFun,&
className::memFun
#endif
现在调用约定也ok了,剩下的也就是怎么实现这个调用过程了,可以想象一下,首先我们通过第一个参数查询map,从中找到对应的MAny对象,然后还原到原始类型,最后调用传递进来的参数执行任务。
思路理清了,接下来就是怎么实现:
//
// 通过函数名查找MAny
//
MAny GetPropertChangedFun(const MString &
funName) const{
if(mPerpertChangedFunMap.count(funName)){
MAny any = mPerpertChangedFunMap.at(funName);
return any;
}
else{
return MAny();
}
}
//
// 获取被执行的函数
//
template<class…Args>
std::function<void(Args…)>MGetPropertChangedFun(
const MString&
funName)
{
try{
typedef std::function<void(Args…)>
funType;
MAny Any = GetPropertChangedFun(funName);
return mj::any_cast<
funType>(Any);
}
catch(mj::bad_any_cast e){
return nullptr;
}
}
有了这两个辅助函数后我们就可以实现
template<class T,class…Args>
void NotifyPropertyChanged(
const MString&
funName,
void(T::*func)(Args…),
Args…agrs
)
{
//
// 获取转发函数
//
std::function<void(Args…)>
fun =
MGetPropertChangedFun<Args…>(funName);
if(fun){
fun(agrs…);
}
}
到了这里就大功告成了,现在将这一部分封装到一个基类中——MProperty
class
MProperty
{
friend class MDataBind;
template<class T>
friend class MConnect;
public:
MProperty();
virtual ~MProperty();
protected:
//
// 将属性被修改的这件事通知出去
// 第一参数为修改属性函数的名字,可以使用 MPropertyNotifer 来调用函数简化操作
// MPropertyNotifer 该宏会对函数名和函数进行参数打包
// eg:
// NotifyPropertyChanged(MPropertyNotifer(className,memFunName),args…)
//
template<class T,class…Args>
void NotifyPropertyChanged(
const MString&
funName,
void(T::*func)(Args…),
Args…agrs
)
{
//
// 获取转发函数
//
std::function<void(Args…)>
fun =
MGetPropertChangedFun<Args…>(funName,this);
if(fun){
fun(agrs…);
}
}
//
// 就算是子类也禁止访问
//
private:
MAny GetPropertChangedFun(const MString &
funName) const;
template<class…Args>
void BindPropertChangedFun(const MString&
funName,const MAny&
fun){
mPerpertChangedFunMap[funName] = fun;
}
//
// 获取多参数函数
//
template<class…Args>
std::function<void(Args…)>MGetPropertChangedFun(
const MString&
funName,
const MProperty* obj)
{
if(obj == nullptr)
return nullptr;
try{
typedef std::function<void(Args…)>
funType;
MAny Any = obj->GetPropertChangedFun(funName);
return mj::any_cast<
funType>(Any);
}
catch(mj::bad_any_cast e){
return nullptr;
}
}
private:
//
// 触发事件的函数名,接收事件的函数
//
MMap<MString,MAny>
mPerpertChangedFunMap;
};
Connect作为MDataBind的静态成员函数,MDataBind作为MProperty的友元类,所以他能够访问到MProperty的私有函数:
class MDataBind
{
public:
MDataBind(){ }
virtual ~MDataBind(){ }
//
// 两个类之间的关联
//
template<class T,class…Args>
static std::shared_ptr<MConnect<T>>Connect(
const MString&
funName,
void(T::*fun1)(Args…),
T* obj1,
std::function<void(Args…)>eventfun
)
{
MAddPropertChangedFun(
funName,
fun1,
obj1,
eventfun);
std::shared_ptr<MConnect<T>>connectObj(new MConnect<T>(funName,obj1,eventfun));
return connectObj;
}
//
// 断开连接
//
template<class T,class…Args>
static
void DisConnect(
const MString&
funName,
void(T::*fun1)(Args…),
T* obj1,
std::function<void(Args…)>eventfun
)
{
std::function<void(Args…)>
fun{nullptr };
(obj1->BindPropertChangedFun)(funName,fun);
}
private:
//
// 添加属性改变函数
//
template<class T,class …Args>
static
void MAddPropertChangedFun(const MString&
funName,
void(T::*fun)(Args…),
T* obj,
std::function<void(Args…)>eventfun)
{
if(obj == nullptr)
return;
(obj->BindPropertChangedFun)(funName,eventfun);
}
};
现在我们再来看看上一讲我们说到的两个类:
class A : public MObject{
public:
void SetValue(const MString&
value){
if (mValue == value)
return;
mValue = value;
NotifyPropertyChanged<A, const MString&
>(
MPropertyNotifer(A, SetValue),
value);
}
private:
MString mValue;
};
class B : public MObject{
public:
void setValue(const MString&
value){
if (mValue == value)
return;
mValue = value;
NotifyPropertyChanged<B, const MString&
>(
MPropertyNotifer(B, setValue),
value);
}
private:
MString mValue;
};
void TestAFun(const MString&
value){
MString str(“TestAFun “);
str <<value;
box::QueBox(str);
}
现在当执行下面程序时首先objA中的值被修改,接着通知objB修改,最后通知自由函数TestAFun
{
A objA;
B objB;
MDataBind::Connect(MSIGNAL(A, SetValue, &
objA),
MSLOT(&
B::setValue,&
objB));
MDataBind::Connect(MSIGNAL(B, setValue, &
objB),
MSLOT(TestAFun));
objA.SetValue(“Hello World”);
}
现在来说一下这个属性的一些用处,他可以用于MVC模型,由于历史原因所以功能单一的他并没有从代码库中被移除,而是在当前版本上稍作修改。
这个版本的不足之处想必大家都看到了,他不支持多播,只能一对一,至于双向绑定不是问题,只需要反向调一下就行,尽管一对一监听已经可以满足我们大部分的需求,但有时候多播还是需要的,另一个问题就是就是不安全性,也就是说当objB被销毁时,槽对象并没有被销魂,他依然能够得到执行,这时候就是未定义行为,新版本解决了这些问题,但是当前版本依然被使用。
下面这个这个table就是以前使用这个属性完成的:
MTableWindow
pTableWindow{nullptr };
// 视图
MTableData
mTableData;
// 数据
然后两者之间相互绑定:
pTableWindow.BindTableData(&
mTableData);
mTableData.BindTableWindow(&
pTableWindow);
我们通过右键触发生成一些随机数来填充数据,然后界面会得到相应的更新,同时如果我们在街面上进行单元格修改,数据也会得到相应的更新。
int row = gen();
// 生成随机的整数
int col = gen();
// 生成随机的整数
mTableData.reSize(row,col);
// 修改数据大小,同时界面的表格也会相应的被修改
HArray<HArray<MString>>data;
for(int i=0;
i<row;
++i){
HArray<MString>v;
for(int j=0;
j<col;
++j){
v<<
fgen();
// 生成随机的浮点数
}
data<<v;
}
mTableData.setData(data);
ok,剩下的问题,如何解决我们上面所说的缺点。
//============================================
回复D查看目录,回复数字查看相应章节
原文始发于微信公众号(
C/C++的编程教室
):第124讲 DirectX11Frame(4)
|