c++ - 具有不可复制类的模板类型推导

Question

假设我有一个 autolocker 类，看起来像这样:

template <T>
class autolocker {
public:
    autolocker(T *l) : lock(l) {
        lock->lock();
    }

    ~autolocker() {
        lock->unlock();
    }
private:
    autolocker(const autolocker&);
    autolocker& operator=(const autolocker&);
private:
    T *lock;
};

显然，目标是能够将此自动锁与任何具有锁定/解锁方法的东西一起使用，而无需诉诸虚拟功能。

目前，它很简单，可以像这样使用:

autolocker<some_lock_t> lock(&my_lock); // my_lock is of type "some_lock_t"

但这样做是违法的:

autolocker lock(&my_lock); // this would be ideal

无论如何，是否有模板类型推导来很好地处理这个问题(保留在我的自动储物柜中是不可复制的)。还是仅指定类型最简单？

Answer 1

是的，你可以使用作用域保护技术

struct autolocker_base {
    autolocker_base() { } 
protected:
    // ensure users can't copy-as it
    autolocker_base(autolocker_base const&) 
    { }

    autolocker_base &operator=(autolocker_base const&)
    { return *this; }
};

template <T>
class autolocker : public autolocker_base {
public:
    autolocker(T *l) : lock(l) {
        lock->lock();
    }

    autolocker(const autolocker& o)
      :autolocker_base(o), lock(o.lock)
    { o.lock = 0; }

    ~autolocker() {
        if(lock)
          lock->unlock();
    }

private:
    autolocker& operator=(const autolocker&);

private:
    mutable T *lock;
};

然后编写一个创建自动锁的函数

template<typename T>
autolocker<T> makelocker(T *l) {
  return autolocker<T>(l);
}

typedef autolocker_base const& autolocker_t;

然后你可以这样写:

autolocker_t lock = makelocker(&my_lock);

一旦 const 引用超出范围，就会调用析构函数。它不需要是虚拟的。至少 GCC optimizes this quite well .

可悲的是，这意味着您必须使您的 locker-object 可复制，因为您需要从 maker 函数返回它。但是旧对象不会尝试解锁两次，因为它的指针在复制时设置为0，所以是安全的。