Move assignment operator

 

C++

语言

概念

实用工具库

字符串库

集装箱库

算法库

迭代器库

Numerics库

输入/输出库

本地化库

正则表达式库 （C++11）

原子操作库 （C++11）

线程的支持库 （C++11）

 

C++语言

大会的主题 原文： General topics 这段文字是通过 Google Translate 自动翻译生成的。 您可以帮助我们检查、纠正翻译中的错误。详情请点击这里。
预处理器 评论 关键字	ASCII表 转义序列 C + +的历史
流量控制 原文： Flow control 这段文字是通过 Google Translate 自动翻译生成的。 您可以帮助我们检查、纠正翻译中的错误。详情请点击这里。
条件执行语句 原文： Conditional execution statements 这段文字是通过 Google Translate 自动翻译生成的。 您可以帮助我们检查、纠正翻译中的错误。详情请点击这里。
if statement	switch statement
迭代语句 原文： Iteration statements 这段文字是通过 Google Translate 自动翻译生成的。 您可以帮助我们检查、纠正翻译中的错误。详情请点击这里。
for loop range-for loop （C++11）	while loop do-while loop
跳转语句 原文： Jump statements 这段文字是通过 Google Translate 自动翻译生成的。 您可以帮助我们检查、纠正翻译中的错误。详情请点击这里。
continue statement break statement	goto statement return statement
功能 原文： Functions 这段文字是通过 Google Translate 自动翻译生成的。 您可以帮助我们检查、纠正翻译中的错误。详情请点击这里。
函数声明
lambda函数的声明
函数模板
的历史。内嵌说明
异常规范 （已弃用）
noexcept说明 （C++11）
例外 原文： Exceptions 这段文字是通过 Google Translate 自动翻译生成的。 您可以帮助我们检查、纠正翻译中的错误。详情请点击这里。
扔表达	try-catch块
命名空间 原文： Namespaces 这段文字是通过 Google Translate 自动翻译生成的。 您可以帮助我们检查、纠正翻译中的错误。详情请点击这里。
命名空间声明	命名空间的别名
类型 原文： Types 这段文字是通过 Google Translate 自动翻译生成的。 您可以帮助我们检查、纠正翻译中的错误。详情请点击这里。
基本类型 复合类型 枚举类型	联合类型 函数类型
decltype specifier （C++11）
规范 原文： Specifiers 这段文字是通过 Google Translate 自动翻译生成的。 您可以帮助我们检查、纠正翻译中的错误。详情请点击这里。
CV符
存储时间说明符
constexpr说明 （C++11）
汽车符 （C++11）
alignas说明 （C++11）
初始化 原文： Initialization 这段文字是通过 Google Translate 自动翻译生成的。 您可以帮助我们检查、纠正翻译中的错误。详情请点击这里。
默认的初始化 值初始化 零初始化 复制初始化 直接初始化	集合初始化 表初始化 （C++11） 常数初始化 参考电压的初始化

常 原文： Literals 这段文字是通过 Google Translate 自动翻译生成的。 您可以帮助我们检查、纠正翻译中的错误。详情请点击这里。
整数文字 字符文字 浮点文字 字符串文字	布尔文字 nullptr （C++11） 用户定义的 （C++11）
表达式 原文： Expressions 这段文字是通过 Google Translate 自动翻译生成的。 您可以帮助我们检查、纠正翻译中的错误。详情请点击这里。
价值类型 为了评价	运营商 运算符的优先级
另一种表示形式
实用工具 原文： Utilities 这段文字是通过 Google Translate 自动翻译生成的。 您可以帮助我们检查、纠正翻译中的错误。详情请点击这里。
类型 原文： Types 这段文字是通过 Google Translate 自动翻译生成的。 您可以帮助我们检查、纠正翻译中的错误。详情请点击这里。
typedef declaration
声明类型别名 （C++11）
属性 （C++11）
施放 原文： Casts 这段文字是通过 Google Translate 自动翻译生成的。 您可以帮助我们检查、纠正翻译中的错误。详情请点击这里。
隐式转换
const_cast conversion
static_cast conversion
dynamic_cast conversion
reinterpret_cast conversion
C-风格和功能转换
内存分配 原文： Memory allocation 这段文字是通过 Google Translate 自动翻译生成的。 您可以帮助我们检查、纠正翻译中的错误。详情请点击这里。
new expression	delete expression
类 原文： Classes 这段文字是通过 Google Translate 自动翻译生成的。 您可以帮助我们检查、纠正翻译中的错误。详情请点击这里。
类的声明 this pointer 访问符	朋友说明 初始化列表
类特定的功能特性 原文： Class-specific function properties 这段文字是通过 Google Translate 自动翻译生成的。 您可以帮助我们检查、纠正翻译中的错误。详情请点击这里。
虚函数 覆盖说明 （C++11） 最后说明 （C++11）	明确的 （C++11） 静态的
特殊的成员函数 原文： Special member functions 这段文字是通过 Google Translate 自动翻译生成的。 您可以帮助我们检查、纠正翻译中的错误。详情请点击这里。
默认构造函数 拷贝构造函数 移动的构造函数 （C++11）	复制的任务 移动分配 （C++11） 析构函数
模板 原文： Templates 这段文字是通过 Google Translate 自动翻译生成的。 您可以帮助我们检查、纠正翻译中的错误。详情请点击这里。
类模板
函数模板
模板特化
参数包 （C++11）
杂项 原文： Miscellaneous 这段文字是通过 Google Translate 自动翻译生成的。 您可以帮助我们检查、纠正翻译中的错误。详情请点击这里。
内联汇编

 

一招赋值操作符类Toperator=，T&&，const T&&，或volatile T&&类型的一个参数的名称const volatile T&&是一个非模板的非静态成员函数。与公众移动赋值运算符是A型MoveAssignable.

原文：

A move assignment operator of class T is a non-template non-static member function with the name operator= that takes exactly one parameter of type T&&, const T&&, volatile T&&, or const volatile T&&. A type with a public move assignment operator is MoveAssignable.

这段文字是通过 Google Translate 自动翻译生成的。
您可以帮助我们检查、纠正翻译中的错误。详情请点击这里。

语法

class_name & class_name :: operator= ( class_name && )	(1)	（C++11 起）
class_name & class_name :: operator= ( class_name && ) = default;	(2)	（C++11 起）
class_name & class_name :: operator= ( class_name && ) = delete;	(3)	（C++11 起）

解释

＃典型的一招赋值运算符的声明

原文：

# Typical declaration of a move assignment operator

这段文字是通过 Google Translate 自动翻译生成的。
您可以帮助我们检查、纠正翻译中的错误。详情请点击这里。

＃强制，此举由编译器生成的赋值运算符

原文：

# Forcing a move assignment operator to be generated by the compiler

这段文字是通过 Google Translate 自动翻译生成的。
您可以帮助我们检查、纠正翻译中的错误。详情请点击这里。

＃避免隐式移动分配

原文：

# Avoiding implicit move assignment

这段文字是通过 Google Translate 自动翻译生成的。
您可以帮助我们检查、纠正翻译中的错误。详情请点击这里。

此举被称为赋值运算符时，它选择重载决议，例如：一个对象时，会出现在一个赋值表达式的左侧，其中的右手侧的相同的或隐式转换的类型是一个rvalue.

原文：

The move assignment operator is called whenever it is selected by 重载决议, e.g. when an object appears on the left side of an assignment expression, where the right-hand side is an rvalue of the same or implicitly convertible type.

这段文字是通过 Google Translate 自动翻译生成的。
您可以帮助我们检查、纠正翻译中的错误。详情请点击这里。

移动赋值操作符典型的“窃取”的参数（例如动态分配的对象的指针，文件描述符，TCP套接字I / O流，正在运行的线程等）的资源，而不是让它们的副本，以及离开的说法在一些有效的，但其他不确定的状态。例如，将分配从std::string或从std::vector叶的右手边参数为空.

原文：

Move assignment operators typically "steal" the resources held by the argument (e.g. pointers to dynamically-allocated objects, file descriptors, TCP sockets, I/O streams, running threads, etc), rather than make copies of them, and leave the argument in some valid but otherwise indeterminate state. For example, move-assigning from a std::string or from a std::vector leaves the right-hand side argument empty.

这段文字是通过 Google Translate 自动翻译生成的。
您可以帮助我们检查、纠正翻译中的错误。详情请点击这里。

隐式声明的移动赋值运算符

如果没有提供用户定义的移动赋值运算符的类类型（struct，class，或union），以下是正确的：

原文：

If no user-defined move assignment operators are provided for a class type (struct, class, or union), and all of the following is true:

这段文字是通过 Google Translate 自动翻译生成的。
您可以帮助我们检查、纠正翻译中的错误。详情请点击这里。

• 有没有用户声明的拷贝构造函数

  原文：

  there are no user-declared copy constructors

  这段文字是通过 Google Translate 自动翻译生成的。
  您可以帮助我们检查、纠正翻译中的错误。详情请点击这里。
• 有没有用户声明的move构造函数

  原文：

  there are no user-declared move constructors

  这段文字是通过 Google Translate 自动翻译生成的。
  您可以帮助我们检查、纠正翻译中的错误。详情请点击这里。
• 有没有用户声明的拷贝赋值运算符

  原文：

  there are no user-declared copy assignment operators

  这段文字是通过 Google Translate 自动翻译生成的。
  您可以帮助我们检查、纠正翻译中的错误。详情请点击这里。
• 有没有用户声明析构函数

  原文：

  there are no user-declared destructors

  这段文字是通过 Google Translate 自动翻译生成的。
  您可以帮助我们检查、纠正翻译中的错误。详情请点击这里。
• 隐式声明的移动赋值操作符就不会被定义为删除

  原文：

  the implicitly-declared move assignment operator would not be defined as deleted

  这段文字是通过 Google Translate 自动翻译生成的。
  您可以帮助我们检查、纠正翻译中的错误。详情请点击这里。

那么编译器会声明的举动分配，运营商inline public类成员的签名

原文：

then the compiler will declare a move assignment operator as an inline public member of its class with the signature

这段文字是通过 Google Translate 自动翻译生成的。
您可以帮助我们检查、纠正翻译中的错误。详情请点击这里。

一个类可以有多个移动赋值运算符，如： T& T::operator=(const T&&)和T& T::operator=(T&&)。如果一些用户自定义的移动赋值操作符都存在，用户仍然可以强制生成的隐式声明的移动赋值操作符与关键字default.

原文：

A class can have multiple move assignment operators, e.g. both T& T::operator=(const T&&) and T& T::operator=(T&&). If some user-defined move assignment operators are present, the user may still force the generation of the implicitly declared move assignment operator with the keyword default.

这段文字是通过 Google Translate 自动翻译生成的。
您可以帮助我们检查、纠正翻译中的错误。详情请点击这里。

由于一些赋值运算符（移动或复制）的任何类，基类的赋值运算符总是宣称永远是隐藏的。如果一个声明是用来把从基类中的赋值运算符，它的参数类型可以是相同的参数类型的隐式派生类的赋值运算符，声明还隐藏着由隐声明.

原文：

Because some assignment operator (move or copy) is always declared for any class, the base class assignment operator is always hidden. If a using-declaration is used to bring in the assignment operator from the base class, and its argument type could be the same as the argument type of the implicit assignment operator of the derived class, the using-declaration is also hidden by the implicit declaration.

这段文字是通过 Google Translate 自动翻译生成的。
您可以帮助我们检查、纠正翻译中的错误。详情请点击这里。

删除隐式声明的移动赋值运算符

隐式声明的或默认的移动赋值操作符类T被定义为“删除”以下是正确的：

原文：

The implicitly-declared or defaulted move assignment operator for class T is defined as deleted in any of the following is true:

这段文字是通过 Google Translate 自动翻译生成的。
您可以帮助我们检查、纠正翻译中的错误。详情请点击这里。

• T有一个非静态数据成员是const

  原文：

  T has a non-static data member that is const

  这段文字是通过 Google Translate 自动翻译生成的。
  您可以帮助我们检查、纠正翻译中的错误。详情请点击这里。
• T有一个非静态数据成员的引用类型.

  原文：

  T has a non-static data member of a reference type.

  这段文字是通过 Google Translate 自动翻译生成的。
  您可以帮助我们检查、纠正翻译中的错误。详情请点击这里。
• T有一个非静态数据成员不能移动分配（已删除，无法访问，或暧昧的举动赋值运算符）

  原文：

  T has a non-static data member that cannot be move-assigned (has deleted, inaccessible, or ambiguous move assignment operator)

  这段文字是通过 Google Translate 自动翻译生成的。
  您可以帮助我们检查、纠正翻译中的错误。详情请点击这里。
• T有直接或虚基类，不能移动分配（已删除，无法访问，或暧昧的举动赋值运算符）

  原文：

  T has direct or virtual base class that cannot be move-assigned (has deleted, inaccessible, or ambiguous move assignment operator)

  这段文字是通过 Google Translate 自动翻译生成的。
  您可以帮助我们检查、纠正翻译中的错误。详情请点击这里。
• T有一个非静态数据成员或直接或虚基类，没有一招赋值运算符，是不平凡复制的.

  原文：

  T has a non-static data member or a direct or virtual base without a move assignment operator that is not trivially copyable.

  这段文字是通过 Google Translate 自动翻译生成的。
  您可以帮助我们检查、纠正翻译中的错误。详情请点击这里。
• T有直接或间接的虚基类

  原文：

  T has a direct or indirect virtual base class

  这段文字是通过 Google Translate 自动翻译生成的。
  您可以帮助我们检查、纠正翻译中的错误。详情请点击这里。

琐碎的举动赋值运算符

隐式声明的移动赋值操作符类T以下是微不足道的，如果是真实的

原文：

The implicitly-declared move assignment operator for class T is trivial if all of the following is true:

这段文字是通过 Google Translate 自动翻译生成的。
您可以帮助我们检查、纠正翻译中的错误。详情请点击这里。

• T没有虚成员函数

  原文：

  T has no virtual member functions

  这段文字是通过 Google Translate 自动翻译生成的。
  您可以帮助我们检查、纠正翻译中的错误。详情请点击这里。
• T没有虚基类

  原文：

  T has no virtual base classes

  这段文字是通过 Google Translate 自动翻译生成的。
  您可以帮助我们检查、纠正翻译中的错误。详情请点击这里。
• 选择每一个直接基础T的移动赋值运算符是微不足道的

  原文：

  The move assignment operator selected for every direct base of T is trivial

  这段文字是通过 Google Translate 自动翻译生成的。
  您可以帮助我们检查、纠正翻译中的错误。详情请点击这里。
• 选择每一个非静态类类型（或类类型的数组）星期四会员T的移动赋值运算符是微不足道的

  原文：

  The move assignment operator selected for every non-static class type (or array of class type) memeber of T is trivial

  这段文字是通过 Google Translate 自动翻译生成的。
  您可以帮助我们检查、纠正翻译中的错误。详情请点击这里。

一个平凡的举动赋值运算符执行相同的简单复制assignmentoperator的行动，就是使对象表示，如果由std::memmove的副本。所有兼容的数据类型与C语言（POD类型）是平凡的移动可分配的

原文：

A trivial move assignment operator performs the same action as the trivial copy assignmentoperator, that is, makes a copy of the object representation as if by std::memmove. All data types compatible with the C language (POD types) are trivially move-assignable.

这段文字是通过 Google Translate 自动翻译生成的。
您可以帮助我们检查、纠正翻译中的错误。详情请点击这里。

隐式定义的移动赋值运算符

如果隐式声明的移动赋值运算符是不会被删除或微不足道的，它的定义，函数体生成和编译的编译器。 union类型，隐式定义的移动赋值操作符复制对象表示（std::memmove）的。对于非工会类类型（class和struct），在移动分配运营商进行完整的成员，明智的举动分配的对象的基础和非静​​态成员，在他们的初始化顺序，使用内置的在分配的标量和移动赋值操作符类的类型.

原文：

If the implicitly-declared move assignment operator is not deleted or trivial, it is defined (that is, a function body is generated and compiled) by the compiler. For union types, the implicitly-defined move assignment operator copies the object representation (as by std::memmove). For non-union class types (class and struct), the move assignment operator performs full member-wise move assignment of the object's bases and non-static members, in their initialization order, using built-in assignment for the scalars and move assignment operator for class types.

这段文字是通过 Google Translate 自动翻译生成的。
您可以帮助我们检查、纠正翻译中的错误。详情请点击这里。

注释

如果复制和移动赋值运算符重载解析选择移动分配的说法是“右值”（或者“prvalue”如一个无名的临时或“xvalue”的结果std::move ），并选择拷贝赋值的说法是“左值”（命名对象或函数/操作符返回左值参考）。如果仅仅是拷贝赋值，所有的参数类别选择（只要它采取它的参数的值或为const，因为右值绑定到const引用），这使得拷贝赋值移动分配的回退，当移动是不可用

原文：

If both copy and move assignment operators are provided, overload resolution selects the move assignment if the argument is an rvalue (either prvalue such as a nameless temporary or xvalue such as the result of std::move), and selects the copy assignment if the argument is lvalue (named object or a function/operator returning lvalue reference). If only the copy assignment is provided, all argument categories select it (as long as it takes its argument by value or as reference to const, since rvalues can bind to const references), which makes copy assignment the fallback for move assignment, when move is unavailable.

这段文字是通过 Google Translate 自动翻译生成的。
您可以帮助我们检查、纠正翻译中的错误。详情请点击这里。

复制和交换赋值运算符

原文：

The copy-and-swap assignment operator

这段文字是通过 Google Translate 自动翻译生成的。
您可以帮助我们检查、纠正翻译中的错误。详情请点击这里。

T& T::operator=(T arg) {
    swap(arg);
    return *this;
}

执行分配一个额外通话费用的右值参数相当于移动的移动构造函数T，这往往是可以接受的.

原文：

performs an equivalent of move assignment for rvalue arguments at the cost of one additional call to the move constructor of T, which is often acceptable.

这段文字是通过 Google Translate 自动翻译生成的。
您可以帮助我们检查、纠正翻译中的错误。详情请点击这里。

示例

#include <string>
#include <iostream>
#include <utility>
 
struct A {
    std::string s;
    A() : s("test") {}
    A(const A& o) : s(o.s) { std::cout << "move failed!\n";}
    A(A&& o) : s(std::move(o.s)) {}
    A& operator=(const A&) { std::cout << "copy assigned\n"; return *this; }
    A& operator=(A&& other) {
         s = std::move(other.s);
         std::cout << "move assigned\n";
         return *this;
    }
};
 
A f(A a) { return a; }
 
struct B : A {
     std::string s2; 
     int n;
     // implicit move assignment operator B& B::operator=(B&&)
     // calls A's move assignment operator
     // calls s2's move assignment operator
     // and makes a bitwise copy of n
};
 
struct C : B {
    ~C() {}; // destructor prevents implicit move assignment
};
 
struct D : B {
    D() {}
    ~D() {}; // destructor would prevent implicit move assignment
    D& operator=(D&&) = default; // force a move assignment anyway 
};
 
int main()
{
    A a1, a2;
    std::cout << "Trying to move-assign A from rvalue temporary\n";
    a1 = f(A()); // move-assignment from rvalue temporary
    std::cout << "Trying to move-assign A from xvalue\n";
    a2 = std::move(a1); // move-assignment from xvalue
 
    std::cout << "Trying to move-assign B\n";
    B b1, b2;
    std::cout << "Before move, b1.s = \"" << b1.s << "\"\n";
    b2 = std::move(b1); // calls implicit move assignment
    std::cout << "After move, b1.s = \"" << b1.s << "\"\n";
 
    std::cout << "Trying to move-assign C\n";
    C c1, c2;
    c2 = std::move(c1); // calls the copy assignment operator
 
    std::cout << "Trying to move-assign E\n";
    D d1, d2;
    d2 = std::move(d1);
}

输出：

Trying to move-assign A from rvalue temporary
move assigned
Trying to move-assign A from xvalue
move assigned
Trying to move-assign B
Before move, b1.s = "test"
move assigned
After move, b1.s = "" 
Trying to move-assign C
copy assigned
Trying to move-assign E
move assigned