1 #include <boost/shared_ptr.hpp>
 2
 3 template <typename WrappedType, typename DerivedAspect>
 4 class BaseAspect
 5 {
 6 protected:
 7   WrappedType* m_wrappedPtr; //被织入的对象
 8
 9   //获取派生的切面对象
10   DerivedAspect* GetDerived()
11   {
12     return static_cast<DerivedAspect*>(this);
13   }
14
15   //被织入对象的删除器，用来自动触发切面中的After方法
16   struct AfterWrapper
17   {
18     DerivedAspect* m_derived;
19     AfterWrapper(DerivedAspect* derived): m_derived(derived) {};
20     void operator()(WrappedType* p)
21     {
22       m_derived->After(p);
23     }
24   };
25 public:
26   explicit BaseAspect(WrappedType* p) :  m_wrappedPtr(p) {};
27
28
29   void Before(WrappedType* p) {
30      // Default does nothing
31   };
32
33   void After(WrappedType* p) {
34      // Default does nothing
35   }
36
37   //重载指针运算符用来织入切面（Before和After）
38   boost::shared_ptr<WrappedType> operator->()
39   {
40     GetDerived()->Before(m_wrappedPtr);
41     return boost::shared_ptr<WrappedType>(m_wrappedPtr, AfterWrapper(GetDerived()));
42   }
43 };
44
45 //织入切面的工厂函数, 返回包含被织入对象的切面
46 template <template <typename> class Aspect, typename WrappedType>
47 Aspect<WrappedType> MakeAspect(WrappedType* p)
48 {
49   return Aspect<WrappedType>(p);
50 }

 1 #include <iostream>
 2 #include <boost/chrono/chrono.hpp>
 3 #include <boost/chrono/system_clocks.hpp>
 4
 5 template<typename WrappedType>
 6 class TimeElapsedAspect : public BaseAspect< WrappedType, TimeElapsedAspect<WrappedType> >
 7 {
 8   typedef  BaseAspect<WrappedType, TimeElapsedAspect<WrappedType> > BaseAspect;
 9   typedef boost::chrono::time_point<boost::chrono::system_clock, boost::chrono::duration<double> > time_point;
10
11   time_point m_tmBegin;
12 public:
13   TimeElapsedAspect(WrappedType* p): BaseAspect(p) {}
14
15
16   void Before(WrappedType* p)
17   {
18     m_tmBegin = boost::chrono::system_clock::now();
19   }
20
21   void After(WrappedType* p)
22   {
23     time_point end = boost::chrono::system_clock::now();
24
25     std::cout << "Time: " << (end-m_tmBegin).count() << std::endl;
26   }
27 };

 1 template <typename WrappedType>
 2 class LoggingAspect : public BaseAspect<WrappedType, LoggingAspect<WrappedType> >
 3 {
 4   typedef  BaseAspect<WrappedType, LoggingAspect<WrappedType> > BaseAspect;
 5 public:
 6   LoggingAspect(WrappedType* p): BaseAspect(p) {}
 7
 8   void Before(WrappedType* p)
 9   {
10     std::cout << "entering" << std::endl;
11   }
12
13   void After(WrappedType* p)
14   {
15     std::cout << "exiting" << std::endl;
16   }
17
18 };

class IX
{
public:IX(){}virtual ~IX(){}virtual void g()=0;
private:};class X : public IX
{
public:void g() {std::cout << "it is a test" << std::endl;}};void TestAop()
{boost::shared_ptr<IX> p(new X());MakeAspect<TimeElapsedAspect>(p.get())->g();MakeAspect<LoggingAspect>(p.get())->g();
}