RAII 技巧

  • 资源获取即初始化
    • 三个保证
      • 构造器获取内存或资源
      • 析构器释放内存或资源
      • 生命周期结束后，自动调用析构器（失效即释放）
      • 关键的意义：异常免疫，保证资源的正确释放

实例

  • RAII-mutex
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    template <class Mutex> 
    class lock_guard {
    public:
    	lock_guard(Mutex& mutex) : mutex_(mutex) { mutex_.lock(); }
    	~lock_guard() { mutex_.unlock(); }
    	// 禁止复制和赋值
    	lock_guard(lock_guard const&) = delete;
    	lock_guard& operator=(lock_guard const&) = delete;
    private:
    	Mutex& mutex_;
    };
  • RAII-smart Pointer
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    template<class T>
    class SmartPoint
    {
    public:
        SmartPoint(T *ptr = nullptr) :point(ptr) {}

        ~SmartPoint() {
            if (point) {
                // 会调用point指向对象的的析构函数
                delete point;
            }
        }
        // 使用智能指针就像使用内部包裹的的对象一样
        T& operator*() { 
            return *point; 
        }

        T* operator->() { 
            return point; 
        }
    private:
        T* point;
    };
  • RAII-装饰器
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    template <typename funcStart, typename funcEnd>
    class scopeField {

    public:
    	enum funcSelector : int {
    		First;
    		Second;
    	}

    public:
    	scopeField(funcStart start, funcEnd end) : _start(start), _end(end) {
    		_start();
    	};
    	~scopeField() {
    		_end();
    	}

    	void func(funcSelector func) {
    		func == funcSelector::First ? _start() : _end();
    	}

    private:
    	funcStart _start;
    	funcEnd _end;

    }