目录

RAII(Resource Acquisition Is Initialization)

ScopeGuard

NVI(Non-Virtual Interface)

CRTP(Curiously Recurring Template Pattern)

PIMPL(Private Implementation)

RAII(Resource Acquisition Is Initialization)

即资源获取就是初始化，是一种管理资源的机制。

如管理new操作符的资源：

      class A
      {
      public:
     	int *p;
     	A(int n)
      	{
      		p = new int[n];
      	}
      	~A()
      	{
     		delete p;
      	}
      };
      int main()
      {
     	A a(10);
     	// a.p
     	return 0;
      }
  
 

只写了一个简单的示例。

一个经典的案例：lock_guard类，源代码如下

     		// CLASS TEMPLATE lock_guard
      template<class _Mutex>
     	class lock_guard
      	{	// class with destructor that unlocks a mutex
      public:
     	using mutex_type = _Mutex;
     	explicit lock_guard(_Mutex& _Mtx)
       : _MyMutex(_Mtx)
       {	// construct and lock
      		_MyMutex.lock();
      		}
     	lock_guard(_Mutex& _Mtx, adopt_lock_t)
      		: _MyMutex(_Mtx)
      		{	// construct but don't lock
      		}
      	~lock_guard() noexcept
      		{	// unlock
      		_MyMutex.unlock();
      		}
     	lock_guard(const lock_guard&) = delete;
      	lock_guard& operator=(const lock_guard&) = delete;
      private:
      	_Mutex& _MyMutex;
      	};
  
 

实例化的时候加锁，生命周期结束的时候自动解锁。

ScopeGuard

这个方法是定义一个ScopeGuard模板类，用于管理临时使用的资源。

把临时资源的释放操作写成lambda表达式，申请ScopeGuard实例存放这个表达式，实例生命周期结束时自动

代码：

      template <typename Lambda>
      class ScopeGuard
      {
      public:
     	ScopeGuard(Lambda &&lam): lambda (lam) {
      	}
      	~ScopeGuard() {
     		lambda();
      	}
      private:
      	Lambda lambda;
      };
      template <typename T>
      ScopeGuard<T> GetScopeGuard(T &&lambda)
      {
     	return ScopeGuard<T>(move(lambda));
      }
      int main()
      {
     	int* p = new int[100];
     	GetScopeGuard([&] {delete[] p; });
     	return 0;
      }
  
 

NVI(Non-Virtual Interface)

NVI是用非虚函数调用虚函数，把非虚函数作为接口。

      class A
      {
      public:
     	void show()
      	{
      		cout << "A\n";
     		print();
      	}
     	virtual void print() {};
      };
      class B :public A
      {
      public:
     	void print()
      	{
      		cout << "x=" << x;
      	}
      private:
     	int x;
      };
      int main()
      {
      	B b;
      	b.show();
     	return 0;
      }
  
 

CRTP(Curiously Recurring Template Pattern)

奇异的递归模板模式，指的是子类继承一个模板类，模板的特化类型是子类本身。

最简代码：

      #include<iostream>
      using namespace std;
      template<typename T>
      class Base
      {
      public:
         void virtualFunc()
          {
             static_cast<T*>(this)->realFunc();
          }
      };
      class Chird :public Base<Chird>
      {
      public:
         void realFunc()
          {
              cout << "real func";
          }
      };
      int main()
      {
         Chird().virtualFunc();
         return 0;
      }
  
 

这个简单的例子就能看出CRTP的写法，也能看出，其实本质上静态多态。

CRTP的好处是，静态多态比继承虚函数的动态多态要快。

应用：

CRTP单例模板

CRTP + 模板方法模式

PIMPL(Private Implementation)

通过一个私有的成员指针，将指针所指向的类的内部实现全部隐藏。

普通代码：

      class A
      {
      public:
     	int f(int n)
      	{
     		return f1(n) + n + f2(n);
      	}
      private:
     	int f1(int n)
      	{
     		return n * n * n;
      	}
     	int f2(int n)
      	{
     		return n > 0 ? 1 : -1;
      	}
      };
  
 

PIMPL代码：

      class B;
      class A
      {
      public:
     	A()
      	{
      		opt = new B();
      	}
     	int f(int n)
      	{
     		return opt->f1(n) + n + opt->f2(n);
      	}
      private:
      	B* opt;
      };
      class B
      {
      public:
     	int f1(int n)
      	{
     		return n * n * n;
      	}
     	int f2(int n)
      	{
     		return n > 0 ? 1 : -1;
      	}
      };
  
 

文章来源: blog.csdn.net，作者：csuzhucong，版权归原作者所有，如需转载，请联系作者。

原文链接：blog.csdn.net/nameofcsdn/article/details/125222648