带有复制/移动分配运算符的enable_if

enable_if with copy/move assignment operator

本文关键字：enable if 运算符 分配 复制 移动      更新时间：2023-10-16

我有一个类，只有当该类的类型参数分别是nothrow copy/move可构造的时，我才希望在该类中启用复制/移动赋值运算符。所以我尝试了这个：

#include <type_traits>
template<typename T>
struct Foobar {
Foobar(T value) : x(value) {}
Foobar(const Foobar &other) : x(other.x) {}
Foobar(Foobar &&other) : x(std::move(other.x)) {}
template<bool Condition = std::is_nothrow_copy_constructible<T>::value,
typename = typename std::enable_if<Condition>::type>
Foobar &operator=(const Foobar &rhs) {
x = rhs.x;
return *this;
}
template<bool Condition = std::is_nothrow_move_constructible<T>::value,
typename = typename std::enable_if<Condition>::type>
Foobar &operator=(Foobar &&rhs) {
x = std::move(rhs.x);
return *this;
}
T x;
};
int main() {
Foobar<int> foo(10);
Foobar<int> bar(20);
foo = bar;
foo.operator=(bar);
return 0;
}

现在，Clang给了我以下错误：

enable_if_test.cpp:31:9: error: object of type 'Foobar<int>' cannot be assigned because its copy assignment operator is implicitly
deleted
foo = bar;
^
enable_if_test.cpp:8:5: note: copy assignment operator is implicitly deleted because 'Foobar<int>' has a user-declared move
constructor
Foobar(Foobar &&other) : x(std::move(other.x)) {}
^
enable_if_test.cpp:32:9: error: call to deleted member function 'operator='
foo.operator=(bar);
~~~~^~~~~~~~~
enable_if_test.cpp:4:8: note: candidate function (the implicit copy assignment operator) has been implicitly deleted
struct Foobar {
^
enable_if_test.cpp:12:13: note: candidate function [with Condition = true, $1 = void]
Foobar &operator=(const Foobar &rhs) {
^
enable_if_test.cpp:19:13: note: candidate function [with Condition = true, $1 = void] not viable: no known conversion from
'Foobar<int>' to 'Foobar<int> &&' for 1st argument
Foobar &operator=(Foobar &&rhs) {
^
2 errors generated.

现在，我包含了对赋值操作符的显式调用，以展示错误的怪异之处。它只是说我的模板是一个候选函数，并没有给出为什么不选择它的原因。

我的猜测是，由于我定义了一个移动构造函数，编译器隐式删除了复制赋值运算符。由于它是隐式删除的，所以它甚至不想实例化任何模板。然而，我不知道它为什么会这样。

我该如何实现这种行为？

(注意：实际的代码有合理的理由来定义每个成员，我知道它在这里是无用的。)

实现这一点的最佳也是唯一的方法是通过零规则——使用编译器提供的赋值运算符和构造函数，它们复制或移动每个成员。如果成员T x不能被复制(移动)分配，那么您的类的复制(移)分配操作符将默认为已删除。

SFINAE不能用于禁用复制和/或移动分配运算符的原因是SFINAE需要模板上下文，但复制和移动分配运算符是非模板成员函数。

用户声明的副本分配operator X::operator=是class X的非静态非模板成员函数，仅具有一个类型为X、X&、const X&、volatile X&或const volatile X&的参数。

由于您的模板版本不算作用户声明的复制(移动)赋值运算符，因此它们不会禁止生成默认的，并且因为首选非模板，默认的将优先于模板定义(当参数是const Foobar&时，否则模板会更好地匹配，但禁用模板仍然不会禁用自动生成的模板)。

如果除了调用成员的复制(移动)赋值运算符之外，还需要一些特殊的逻辑，请在子对象中实现它(基或成员都可行)。

您可以通过从用作基类的类模板的专业化中进行选择，并在继承时传递适当的类型特征来实现您的目标：

template<bool allow_copy_assign, bool allow_move_assign>
struct AssignmentEnabler;
template<typename T>
struct Foobar : AssignmentEnabler<std::is_nothrow_copy_constructible<T>::value, 
std::is_nothrow_move_constructible<T>::value>
{
};

当且仅当选定的AssignmentEnabler基类进行了复制和移动赋值时，派生类型将使用零规则默认为进行复制和移动指派。您必须为四种组合中的每一种指定AssignmentEnabler(既不复制也不移动、复制而不移动、移动而不复制，两者都有)。

完成您问题中代码的转换：

#include <type_traits>
template<bool enable>
struct CopyAssignmentEnabler {};
template<>
struct CopyAssignmentEnabler<false>
{
CopyAssignmentEnabler() = default;
CopyAssignmentEnabler(const CopyAssignmentEnabler&) = default;
CopyAssignmentEnabler(CopyAssignmentEnabler&&) = default;
CopyAssignmentEnabler& operator=(const CopyAssignmentEnabler&) = delete;
CopyAssignmentEnabler& operator=(CopyAssignmentEnabler&&) = default;
};
template<bool enable>
struct MoveAssignmentEnabler {};
template<>
struct MoveAssignmentEnabler<false>
{
MoveAssignmentEnabler() = default;
MoveAssignmentEnabler(const MoveAssignmentEnabler&) = default;
MoveAssignmentEnabler(MoveAssignmentEnabler&&) = default;
MoveAssignmentEnabler& operator=(const MoveAssignmentEnabler&) = default;
MoveAssignmentEnabler& operator=(MoveAssignmentEnabler&&) = delete;
};
template<typename T>
struct Foobar : CopyAssignmentEnabler<std::is_nothrow_copy_constructible<T>::value>,
MoveAssignmentEnabler<std::is_nothrow_move_constructible<T>::value>
{
Foobar(T value) : x(value) {}
T x;
};
int main() {
Foobar<int> foo(10);
Foobar<int> bar(20);
foo = bar;
foo.operator=(bar);
return 0;
}
相关文章：