为什么 C++11 标准的早期草案中没有默认的移动赋值/移动构造函数？

Question

我是一个简单的程序员。我的类成员变量通常由 POD 类型和 STL 容器组成。因此，我很少需要编写赋值运算符或复制构造函数，因为它们是默认实现的。

除此之外，如果我在不可移动的对象上使用 std::move ，它会使用赋值运算符，这意味着 std::move 是完全安全的。

由于我是一个简单的程序员，我想利用移动功能，而不向我编写的每个类添加移动构造函数/赋值运算符，因为编译器可以简单地将它们实现为“this->; member1_ = std::move(other.member1_);..."

但它没有（至少在 Visual 2010 中没有），这有什么特殊原因吗？

更重要的是； 有什么办法可以解决这个问题吗？

更新： 如果你看一下 GManNickG 的答案，他为此提供了一个很棒的宏。如果您不知道，如果您实现 move-semantics，则可以删除交换成员函数。

Answer 1

移动构造函数和赋值运算符的隐式生成一直存在争议，并且 C++ 标准的最新草案进行了重大修订，因此当前可用的编译器在隐式生成方面的行为可能会有所不同。

有关该问题历史记录的更多信息，请参阅2010 年 WG21 论文列出 并搜索“mov”

当前规范（N3225，从 11 月开始）规定 (N3225 12.8/8)：

如果类X的定义没有显式声明移动构造函数，当且仅当

• X 没有用户声明的复制构造函数，并且

• X 没有用户声明的复制赋值运算符，

• X 没有用户声明的移动赋值运算符，

• X 没有用户声明的析构函数，并且

• 移动构造函数不会被隐式定义为已删除。

12.8/22 中有类似的语言，指定何时将移动赋值运算符隐式声明为默认值。您可以在 N3203：收紧生成隐式移动的条件
，该决议主要基于 Bjarne Stroustrup 的论文 N3201：向右移动。

Answer 2

标准已考虑隐式生成的移动构造函数，但可能很危险。请参阅 Dave Abrahams 的分析。

然而，最终，该标准确实包括了移动构造函数和移动赋值运算符的隐式生成，尽管有相当多的限制：

如果类 X 的定义没有显式声明移动构造函数，则当且仅当
— X 没有用户声明的复制构造函数，
— X 没有用户声明的复制赋值运算符，
— X 没有用户声明的移动赋值运算符，
— X 没有用户声明的析构函数，并且
— 移动构造函数不会被隐式定义为已删除。

但这还不是故事的全部。可以声明一个ctor，但仍然定义为已删除：

隐式声明的复制/移动构造函数是其类的内联公共成员。如果 X 具有以下特征，则类 X 的默认复制/移动构造函数被定义为已删除 (8.4.3)：

— 具有非平凡对应构造函数的变体成员，并且 X 是类似联合的类，
— 类类型 M（或其数组）的非静态数据成员，无法复制/移动，因为应用于 M 相应构造函数的重载决策 (13.3) 会导致歧义或函数被删除或无法从默认构造函数，
— 无法复制/移动的直接或虚拟基类 B，因为应用于 B 相应构造函数的重载解析 (13.3) 会导致歧义或从默认构造函数中删除或无法访问函数，
— 具有析构函数的类型的任何直接或虚拟基类或非静态数据成员，该析构函数已被删除或无法从默认构造函数访问，
— 对于复制构造函数，右值引用类型的非静态数据成员，或
— 对于移动构造函数，是一个非静态数据成员或者直接或虚拟基类，其类型不具有移动构造函数并且不可简单复制。

Answer 3

（就目前而言，我正在研究一个愚蠢的宏......）

是的，我也走了那条路。这是你的宏：

// detail/move_default.hpp
#ifndef UTILITY_DETAIL_MOVE_DEFAULT_HPP
#define UTILITY_DETAIL_MOVE_DEFAULT_HPP

#include <boost/preprocessor.hpp>

#define UTILITY_MOVE_DEFAULT_DETAIL_CONSTRUCTOR_BASE(pR, pData, pBase) pBase(std::move(pOther))
#define UTILITY_MOVE_DEFAULT_DETAIL_ASSIGNMENT_BASE(pR, pData, pBase) pBase::operator=(std::move(pOther));

#define UTILITY_MOVE_DEFAULT_DETAIL_CONSTRUCTOR(pR, pData, pMember) pMember(std::move(pOther.pMember))
#define UTILITY_MOVE_DEFAULT_DETAIL_ASSIGNMENT(pR, pData, pMember) pMember = std::move(pOther.pMember);

#define UTILITY_MOVE_DEFAULT_DETAIL(pT, pBases, pMembers)                                               \
        pT(pT&& pOther) :                                                                               \
        BOOST_PP_SEQ_ENUM(BOOST_PP_SEQ_TRANSFORM(                                                       \
            UTILITY_MOVE_DEFAULT_DETAIL_CONSTRUCTOR_BASE, BOOST_PP_EMPTY, pBases))                      \
        ,                                                                                               \
        BOOST_PP_SEQ_ENUM(BOOST_PP_SEQ_TRANSFORM(                                                       \
            UTILITY_MOVE_DEFAULT_DETAIL_CONSTRUCTOR, BOOST_PP_EMPTY, pMembers))                         \
        {}                                                                                              \
                                                                                                        \
        pT& operator=(pT&& pOther)                                                                      \
        {                                                                                               \
            BOOST_PP_SEQ_FOR_EACH(UTILITY_MOVE_DEFAULT_DETAIL_ASSIGNMENT_BASE, BOOST_PP_EMPTY, pBases)  \
            BOOST_PP_SEQ_FOR_EACH(UTILITY_MOVE_DEFAULT_DETAIL_ASSIGNMENT, BOOST_PP_EMPTY, pMembers)     \
                                                                                                        \
            return *this;                                                                               \
        }

#define UTILITY_MOVE_DEFAULT_BASES_DETAIL(pT, pBases)                                                   \
        pT(pT&& pOther) :                                                                               \
        BOOST_PP_SEQ_ENUM(BOOST_PP_SEQ_TRANSFORM(                                                       \
            UTILITY_MOVE_DEFAULT_DETAIL_CONSTRUCTOR_BASE, BOOST_PP_EMPTY, pBases))                      \
        {}                                                                                              \
                                                                                                        \
        pT& operator=(pT&& pOther)                                                                      \
        {                                                                                               \
            BOOST_PP_SEQ_FOR_EACH(UTILITY_MOVE_DEFAULT_DETAIL_ASSIGNMENT_BASE, BOOST_PP_EMPTY, pBases)  \
                                                                                                        \
            return *this;                                                                               \
        }

#define UTILITY_MOVE_DEFAULT_MEMBERS_DETAIL(pT, pMembers)                                               \
        pT(pT&& pOther) :                                                                               \
        BOOST_PP_SEQ_ENUM(BOOST_PP_SEQ_TRANSFORM(                                                       \
            UTILITY_MOVE_DEFAULT_DETAIL_CONSTRUCTOR, BOOST_PP_EMPTY, pMembers))                         \
        {}                                                                                              \
                                                                                                        \
        pT& operator=(pT&& pOther)                                                                      \
        {                                                                                               \
            BOOST_PP_SEQ_FOR_EACH(UTILITY_MOVE_DEFAULT_DETAIL_ASSIGNMENT, BOOST_PP_EMPTY, pMembers)     \
                                                                                                        \
            return *this;                                                                               \
        }

#endif

// move_default.hpp
#ifndef UTILITY_MOVE_DEFAULT_HPP
#define UTILITY_MOVE_DEFAULT_HPP

#include "utility/detail/move_default.hpp"

// move bases and members
#define UTILITY_MOVE_DEFAULT(pT, pBases, pMembers) UTILITY_MOVE_DEFAULT_DETAIL(pT, pBases, pMembers)

// base only version
#define UTILITY_MOVE_DEFAULT_BASES(pT, pBases) UTILITY_MOVE_DEFAULT_BASES_DETAIL(pT, pBases)

// member only version
#define UTILITY_MOVE_DEFAULT_MEMBERS(pT, pMembers) UTILITY_MOVE_DEFAULT_MEMBERS_DETAIL(pT, pMembers)

#endif

（我已经删除了真实的注释，这些注释是长度和记录的。）

您将类中的基类和/或成员指定为预处理器列表，例如：

#include "move_default.hpp"

struct foo
{
    UTILITY_MOVE_DEFAULT_MEMBERS(foo, (x)(str));

    int x;
    std::string str;
};

struct bar : foo, baz
{
    UTILITY_MOVE_DEFAULT_BASES(bar, (foo)(baz));
};

struct baz : bar
{
    UTILITY_MOVE_DEFAULT(baz, (bar), (ptr));

    void* ptr;
};

然后出现一个移动构造函数和移动赋值运算符。

（顺便说一句，如果有人知道我如何将细节组合到一个宏中，那就太好了。）

Answer 4

VS2010 没有这样做，因为它们在实现时不是标准的。