有条件地禁用复制构造函数

Question

假设我正在编写一个类模板C<T>，它包含一个T 值，那么只有当T 是可复制的时，C<T> 才能是可复制的。通常，当模板可能支持或可能不支持某个操作时，您只需定义该操作，并由调用者在不安全时避免调用它：

template <typename T>
class C {
 private:
  T t;

 public:
  C(const C& rhs);
  C(C&& rhs);

  // other stuff
};

但是，这在复制构造函数的情况下会产生问题，因为即使T 不可复制，is_copy_constructible<C<T>> 也会为真；如果调用该特征，则该特征看不到复制构造函数的格式错误。 这是一个问题，例如，如果std::is_copy_constructible 为真，vector 有时会避免使用移动构造函数。我该如何解决这个问题？

如果构造函数显式或隐式默认，我相信is_copy_constructible 会做正确的事：

template <typename T>
class C {
 private:
  T t;

 public:
  C(const C& rhs) = default;
  C(C&& rhs) = default;

  // other stuff
};

但是，并非总是可以构造您的类，以便默认构造函数执行正确的操作。

我能看到的另一种方法是使用 SFINAE 有条件地禁用复制构造函数：

template <typename T>
class C {
 private:
  T t;

 public:
  template <typename U = C>
  C(typename std::enable_if<std::is_copy_constructible<T>::value,
                            const U&>::type rhs);
  C(C&& rhs);

  // other stuff
};

除了丑陋之外，这种方法的问题在于我必须将构造函数设为模板，因为 SFINAE 仅适用于模板。根据定义，复制构造函数不是模板，所以我禁用/启用的东西实际上不是复制构造函数，因此它不会抑制编译器隐式提供的复制构造函数。

我可以通过显式删除复制构造函数来解决这个问题：

template <typename T>
class C {
 private:
  T t;

 public:
  template <typename U = C>
  C(typename std::enable_if<std::is_copy_constructible<T>::value,
                            const U&>::type rhs);
  C(const C&) = delete;
  C(C&& rhs);

  // other stuff
};

但这仍然不能阻止在重载决议期间考虑复制构造函数。这是一个问题，因为在其他条件相同的情况下，普通函数将在重载决议中击败函数模板，因此当您尝试复制 C<T> 时，普通的复制构造函数会被选中，即使 T 也会导致构建失败是可复制的。

我能发现原则上可行的唯一方法是从主模板中省略复制构造函数，并以部分特化的方式提供它（当 T 不可复制时，使用更多的 SFINAE 技巧来禁用它）。但是，这很脆弱，因为它需要我复制C 的整个定义，这会产生两个副本不同步的重大风险。我可以通过让方法体共享代码来缓解这种情况，但我仍然必须复制类定义和构造函数成员初始化列表，这为错误潜入提供了足够的空间。我可以通过让它们都继承来进一步缓解这种情况来自一个公共基类，但引入继承可能会产生各种不受欢迎的后果。此外，当我想要做的只是禁用一个构造函数时，公共继承似乎是适合这项工作的错误工具。

有没有我没有考虑过的更好的选择？

Answer 1

一个值得注意的方法是对周围的类模板进行部分特化。

template <typename T,
          bool = std::is_copy_constructible<T>::value>
struct Foo
{
    T t;

    Foo() { /* ... */ }
    Foo(Foo const& other) : t(other.t) { /* ... */ }
};

template <typename T>
struct Foo<T, false> : Foo<T, true>
{
    using Foo<T, true>::Foo;

    // Now delete the copy constructor for this specialization:
    Foo(Foo const&) = delete;

    // These definitions adapt to what is provided in Foo<T, true>:
    Foo(Foo&&) = default;
    Foo& operator=(Foo&&) = default;
    Foo& operator=(Foo const&) = default;
};

这样is_copy_constructible 的特征在T is_copy_constructible 的位置得到满足。

Answer 2

但是，并非总是可以构造您的类，以便默认构造函数执行正确的操作。

只要付出足够的努力通常是可能的。

将默认构造函数无法完成的工作委托给另一个成员，或将T 成员包装在执行复制的某个包装器中，或将其移动到定义相关操作的基类中。

那么你可以定义拷贝构造函数为：

  C(const C&) = default;

让编译器决定是否删除默认定义的另一种方法是通过基类：

template<bool copyable>
struct copyable_characteristic { };

template<>
struct copyable_characteristic<false> {
  copyable_characteristic() = default;
  copyable_characteristic(const copyable_characteristic&) = delete;
};

template <typename T>
class C
: copyable_characteristic<std::is_copy_constructible<T>::value>
{
 public:
  C(const C&) = default;
  C(C&& rhs);

  // other stuff
};

这可用于删除使用任意条件的操作，例如 is_nothrow_copy_constructible 而不仅仅是简单的 T 是可复制的，意味着 C 是可复制的规则。

Answer 3

如果您想有条件地禁用您的复制构造函数，您肯定希望它参与重载解析 - 因为如果您尝试复制它，您希望它是一个响亮的编译错误。

为此，您只需要static_assert:

template <typename T>
class C {
public:
    C(const C& rhs) {
        static_assert(some_requirement_on<T>::value, 
            "copying not supported for T");
    }
};

仅当some_requirement_on<T> 为真时才允许复制构造，如果为假，您仍然可以使用该类的其余部分...只是不要复制构造。如果你这样做了，你会得到一个指向这一行的编译错误。

这是一个简单的例子：

template <typename T>
struct Foo
{
    Foo() { }

    Foo(const Foo& ) {
        static_assert(std::is_integral<T>::value, "");
    }

    void print() {
        std::cout << "Hi" << std::endl;
    }
};

int main() {
    Foo<int> f;
    Foo<int> g(f); // OK, satisfies our condition
    g.print();     // prints Hi

    Foo<std::string> h;
    //Foo<std::string> j(h); // this line will not compile
    h.print(); // prints Hi
}

Answer 4

template <typename T>
class variant {
    struct moo {};
public:
  variant(const variant& ) = default;
  variant(std::conditional_t<!std::is_copy_constructible<T>::value,
                             const variant&, moo>,
          moo=moo());
  variant() {};
};

这使得不符合条件的模板实例具有两个复制构造函数，这使得它不能复制构造。

Answer 5

这有点小技巧，但确实有效。

template<bool b,class T>
struct block_if_helper{
  using type=T;
};
template<class T>
struct block_if_helper<true, T>{
  class type{
    type()=delete;
  };
};
template<bool b,classT>
using block_if=typename block_if_helper<b,T>::type;
template<bool b,classT>
using block_unless=typename block_if_helper<!b,T>::type;

现在我们创建一个方法，它是您的复制 ctor ...也许吧。

template<class X>
struct example {
  enum { can_copy = std::is_same<X,int>{} };

  example( block_unless<can_copy, example>const& o ); // implement this as if `o` was an `example`
  // = default not allowed
  example( block_if<can_copy, example>const& )=delete;
};

现在=default 是复制ctor 当且仅当can_copy 和=delete 不是。否则无法创建存根类型。

我发现这种技术对于在不支持默认模板参数功能的编译器上禁用通用方法或对于不能为 templates 的方法（如 virtual 或特殊方法）很有用。

Answer 6

C::C(C const& rhs, std::enable_if<true, int>::type dummy = 0) 也是一个复制 ctor，因为第二个参数有一个默认值。