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

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。

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

Answer 2

很明显，autolocker 是模板，因为您想将其用作类型，并且模板必须实例化才能获得类型。

但是类型擦除可以用来做你想做的事。你把类模板变成一个类，把它的构造函数变成一个成员模板。但是你必须动态分配一个内部实现对象。
更好的是，存储一个指向执行解锁的函数的指针，并让该函数成为模板化构造函数选择的模板的实例。类似这样的事情：

// Comeau compiles this, but I haven't tested it. 
class autolocker {
public:
    template< typename T >
    autolocker(T *l) : lock_(l), unlock_(&unlock<T>) { l->lock(); }

    ~autolocker()                                    { unlock_(lock_); }
private:
    autolocker(const autolocker&);
    autolocker& operator=(const autolocker&);
private:
    typedef void (*unlocker_func_)(void*);

    void *lock_;
    unlocker_func_ unlock_;

    template <typename T>
    static void unlock(void* lock)                   { ((T*)lock)->unlock(); }
};

我实际上并没有尝试过这个，语法可能是错误的（我不确定如何获取特定函数模板实例的地址），但我认为这在原则上应该是可行的。也许有人会出现并修复我做错的地方。

我更喜欢这个范围保护，出于某种原因，我从来没有真正喜欢过它。

Answer 3

我认为 jwismar 是正确的，而 C++ 无法实现您想要的。然而，类似的（非直接模拟）构造可以使用 C++0x，使用几个新特性（右值/移动和自动变量类型）：

#include <iostream>

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

  autolocker_impl (autolocker_impl&& that)
    : lock (that.lock)
  {
    that.lock = 0;
  }

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

template <typename T>
autolocker_impl <T>
autolocker (T* lock)
{
  return autolocker_impl <T> (lock);
}

struct lock_type
{
  void lock ()
  { std::cout << "locked\n"; }
  void unlock ()
  { std::cout << "unlocked\n"; }
};

int
main ()
{
  lock_type l;
  auto x = autolocker (&l);
}

Answer 4

autolocker 是类模板，而不是类。您的“这将是理想的”显示了在 C++ 中没有意义的东西。