要在C++中应用AOP,不像在其他的基于解释器的语言中那么方便,作为一种静态语言,如果给函数或者类的方法造一个wrapper,在wrapper里面嵌入调用前的代码和调用后的代码,也能达到一定程度的代码织入的效果。在C++11之前,要给一个函数或者方法做个能返回调用结果的wrapper并不简单,会比较复杂,而在C++11里面可以使用function模版,以及函数返回类型的推定,通过生成一个内嵌类的对象的构造函数来执行before动作,析构函数来实现after动作,而具体的before和action动作则可以通过lambda或者函数来表示,这样子实现起来就容易很多了,而且还可以设定一个对象给before/after动作作参数。
先看看函数的wrapper:
template<typename T, typename Probe>
struct Wrapper<T*, Probe>{
typedef function<void(Probe)> WrapFuncType;
T* _func;
Probe _probe;
WrapFuncType _after,
_before;
struct WrapInternal{
Wrapper<T*, Probe>* _wrapper;
WrapInternal(Wrapper<T*,Probe>* w) : _wrapper(w){
_wrapper->_before( _wrapper->_probe );
}
~WrapInternal(){
_wrapper->_after( _wrapper->_probe );
}
};
Wrapper(T* func,
Probe p,
WrapFuncType callBefore = [](Probe p){},
WrapFuncType callAfter = [](Probe p){}) : _probe(p){
_func = func;
_after = callAfter;
_before = callBefore;
}
template<typename ...Args>
auto operator()(Args && ...args)
->decltype( (*_func)(args...) ){
WrapInternal _w(this);
return (*_func)(args...);
}
};
这个 wrapper 能够包裹一个函数,生成的对象的调用也像原来的函数的调用一样调用:
int foo_int(int a) {
cout << "foo_int: " << a << endl;
return a * a;
}
typedef Wrapper<int(*)(int), int> T1;
T1 w4(&foo_int, 100,
[](int v){ cout << "w4<100> before" << endl; },
[](int v){ cout << "w4<100> after" << endl; });
cout << w4(400) << endl;
如果要给一个类方法做个wrapper,则可以按照如下方法:
template<typename T, typename Object, typename Probe>
struct Wrapper<T, Object, Probe>{
typedef function<void(Probe)> WrapFuncType;
T _method;
Object _obj;
Probe _probe;
WrapFuncType _after,
_before;
struct WrapInternal{
Wrapper<T, Object, Probe>* _wrapper;
WrapInternal(Wrapper<T, Object, Probe>* w) : _wrapper(w){
_wrapper->_before( _wrapper->_probe );
}
~WrapInternal(){
_wrapper->_after( _wrapper->_probe );
}
};
Wrapper(T&& method,
Object&& obj,
Probe p,
WrapFuncType callBefore = [](Probe p){},
WrapFuncType callAfter = [](Probe p){} ) : _probe(p){
_method = method;
_obj = obj;
_after = callAfter;
_before = callBefore;
}
template<typename ...Args>
auto operator()(Args && ...args)
->decltype(bind(_method, _obj, args...)(args...)) {
WrapInternal _w( this );
auto b = bind(_method, _obj, args...);
return b(args...);
}
};
使用的时候,设置好类名、对象、和方法:
struct Foo{
Foo(){
cout << "Foo::Foo" << endl;
}
void bar(int v){
cout << "Foo::bar " << v << endl;
}
};
typedef Wrapper<void(Foo::*)(int), Foo*, const char*> T2;
Foo f;
T2 w5(&Foo::bar, &f, "method",
[](const char* v){ cout << "w5<method> before" << endl;},
[](const char* v){ cout << "w5<method> after" << endl;});
w5(500);
通过这2种方法生成的wrapper对象还可以当作函数一样再次套上一个wrapper,也就是通过这种方法可以实现多个层次嵌套的wrapper,调用的时候从外到里的次序调用before动作,执行完原函数或者方法之后,再按照从里到外的次序调用after动作,最后返回原函数或者方法的返回值。
访问 https://github.com/icandroid/wrapper11 可以查看这个 wrapper 的源代码和演示例子。