Move assignment operator

De cppreference.com

This page has been machine-translated from the English version of the wiki using Google Translate.

The translation may contain errors and awkward wording. Hover over text to see the original version. You can help to fix errors and improve the translation. For instructions click here.

Click here for the English version of this page

Lenguaje C++

Los temas generales

Preprocessor
Comentarios
Palabras clave

Tabla ASCII
Las secuencias de escape
Historia de C++

Control de flujo

Sentencias condicionales ejecución

if statement

switch statement

Instrucciones de iteración

`for` loop
range-`for` loop (C++11)

`while` loop
`do-while` loop

Ir declaraciones

`continue` statement
`break` statement

`goto` statement
`return` statement

Funciones

declaración de la función

lambda declaración de la función

función de plantilla

especificador inline

especificaciones de excepción (obsoleto)

noexcept especificador (C++11)

Excepciones

tirar expresión

bloque try-catch

Los espacios de nombres

espacio de nombres declaración

alias de espacios de nombres

Tipos

tipos fundamentales
tipos de compuestos
los tipos de enumeración

tipos de unión
tipos de funciones

decltype specifier (C++11)

Los especificadores

cv especificadores

almacenamiento duración especificadores

constexpr especificador (C++11)

auto especificador (C++11)

alignas especificador (C++11)

Inicialización

predeterminado de inicialización
valor de inicialización
cero de inicialización
copiar inicialización
inicialización directa

inicialización de agregados
lista de inicialización (C++11)
inicialización constante
referencia de inicialización

Los literales

literales enteros
Los literales de caracteres
Los literales de punto flotante
literales de cadena

Los literales booleanos
nullptr (C++11)
definido por el usuario (C++11)

Expresiones

categorías de valor
orden de evaluación

los operadores
prioridad de los operadores

representaciones alternativas

Utilidades

Tipos

typedef declaration

alias de tipo de declaración (C++11)

atributos (C++11)

Lanza

conversiones implícitas

const_cast conversion

static_cast conversion

dynamic_cast conversion

reinterpret_cast conversion

C-cast estilo y funcional

De asignación de memoria

new expression

delete expression

Clases

clase de declaración
`this` pointer
acceder a los especificadores

amigo especificador
listas de inicializadores

Clase propiedades específicas de la función

función virtual
anular especificador (C++11)
último especificador (C++11)

explícita (C++11)
estático

Funciones especiales miembro

default constructor
copiar constructor
mover constructor (C++11)

copiar asignación
mover asignación (C++11)
destructor

Plantillas

clase de plantilla

función de plantilla

plantilla de especialización

paquetes de parámetros (C++11)

Varios

Montaje en línea

[edit]

Un operador de asignación movimiento de T clase es un no-no estático plantilla función miembro con el operator= nombre que lleva exactamente un parámetro de tipo T&&, const T&&, volatile T&& o const volatile T&&. Un tipo con un operador de movimiento asignación pública es MoveAssignable .

Contenido

1 Sintaxis
2 Explicación
3 Implícitamente, declarado operador mover asignación
4 Suprimido implícitamente declarada operador mover asignación
5 Movimiento Trivial operador de asignación
6 Implícitamente operador definido movimiento asignación
7 Notas
8 Ejemplo

[editar] Sintaxis


class_name `&` class_name `:: operator=` ( class_name `&&` )	(1)	(ya que C + +11)

class_name `&` class_name `:: operator=` ( class_name `&&` ) = default;	(2)	(ya que C + +11)

class_name `&` class_name `:: operator=` ( class_name `&&` ) = delete;	(3)	(ya que C + +11)

[editar] Explicación

# Declaración típica de un operador de asignación movimiento

# Obligar a un operador de asignación movimiento que se genere por el compilador

# Evitar la asignación movimiento implícito

El operador de asignación movimiento se llama cada vez que se selecciona por sobrecarga resolución, por ejemplo, cuando un objeto aparece en el lado izquierdo de una expresión de asignación, donde el lado derecho es un valor p del mismo tipo o convertible implícitamente .

Mueva los operadores de asignación típicamente "robar" los recursos mantenidos por el argumento (por ejemplo, punteros a objetos dinámicamente asignados, los descriptores de archivos, sockets TCP, I / O, hilos corrientes de funcionamiento, etc), en lugar de hacer copias de ellos, y dejar el argumento en un estado válido, pero indeterminado de otra manera. Por ejemplo, el movimiento de la asignación de un std::string o de un std::vector deja el argumento mano derecha vacía .

[editar] Implícitamente, declarado operador mover asignación

Si no definidos por el usuario operadores de asignación se mueven se proporcionan para un tipo de clase (struct, class o union), y todas las siguientes condiciones:

no hay constructores de copia declaradas por el usuario
Original:
there are no user-declared copy constructors
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
No hay constructores movimiento declarados por el usuario
Original:
there are no user-declared move constructors
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
no hay operadores de copia por el usuario declara asignación
Original:
there are no user-declared copy assignment operators
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
No hay destructores declarados por el usuario
Original:
there are no user-declared destructors
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
el operador de asignación movimiento implícitamente declarada no sería definido como eliminado
Original:
the implicitly-declared move assignment operator would not be defined as deleted
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.

entonces el compilador declarar un operador de asignación se mueven como miembro inline public de su clase con el firma

Una clase puede tener varios operadores de asignación se mueven, por ejemplo, tanto T& T::operator=(const T&&) y T& T::operator=(T&&). Si algunos definidos por el usuario de operadores de asignación movimiento están presentes, el usuario todavía puede forzar la generación de la asignación implícita movimiento operador declarado con la palabra clave default .

Debido a que algunas operador de asignación (mover o copiar) siempre se declara de cualquier clase, la clase base operador de asignación es siempre oculto. Si se utiliza-declaración se utiliza para traer el operador de asignación de la clase base, y su tipo de argumento podría ser el mismo que el tipo de argumento del operador de asignación implícita de la clase derivada, el uso de declaración también se oculta por el implícito declaración .

[editar] Suprimido implícitamente declarada operador mover asignación

El operador de asignación movimiento implícitamente declaradas o cesación de pagos por T clase se define como borrado en cualquiera de las siguientes situaciones:

T tiene un miembro no estático de datos que es const
Original:
T has a non-static data member that is const
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
T tiene un miembro no estático de datos de un tipo de referencia .
Original:
T has a non-static data member of a reference type.
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
T tiene un miembro no estático de datos que no se pueden mover-asignado (se ha borrado, inaccesible, o ambiguo movimiento operador de asignación)
Original:
T has a non-static data member that cannot be move-assigned (has deleted, inaccessible, or ambiguous move assignment operator)
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
T tiene clase base directa o virtual que no se puede mover-asignado (se ha borrado, inaccesible, o ambiguo movimiento operador de asignación)
Original:
T has direct or virtual base class that cannot be move-assigned (has deleted, inaccessible, or ambiguous move assignment operator)
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
T tiene un miembro no estático de datos o una base directa o virtual sin necesidad de un operador de asignación movimiento que no es trivial copiable .
Original:
T has a non-static data member or a direct or virtual base without a move assignment operator that is not trivially copyable.
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
T tiene una clase virtual de base directa o indirecta
Original:
T has a direct or indirect virtual base class
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.

[editar] Movimiento Trivial operador de asignación

El operador de asignación movimiento implícitamente declarado para T clase es trivial si todo lo siguiente es cierto:

T no tiene funciones miembro virtuales
Original:
T has no virtual member functions
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
T no tiene clases base virtuales
Original:
T has no virtual base classes
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
El operador de asignación movimiento seleccionado para cada base directa de T es trivial
Original:
The move assignment operator selected for every direct base of T is trivial
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
El operador de asignación movimiento seleccionado para cada tipo de clase no estática (o matriz de tipo de clase) memeber de T es trivial
Original:
The move assignment operator selected for every non-static class type (or array of class type) memeber of T is trivial
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.

Un operador de asignación movimiento trivial realiza la misma acción que el assignmentoperator copia trivial, es decir, hace una copia de la representación de objetos como por std::memmove. Todos los tipos de datos compatibles con el lenguaje C (tipos POD) son trivialmente mover asignable .

[editar] Implícitamente operador definido movimiento asignación

Si el operador de movimiento asignación implícita-declarado no se elimina o trivial, se define (es decir, un cuerpo de función se genera y compila) por el compilador. Para los tipos de union, el operador de asignación movimiento implícitamente definido por copia la representación de objetos (como por std::memmove). Para los tipos de clase no sindicalizados (class y struct), el operador de asignación movimiento realiza miembro de pleno derecho-sabio asignación movimiento de bases del objeto y de los miembros no estáticos, en su orden de inicialización, utilizando una función de asignación para los escalares y operador de asignación movimiento para los tipos de clase .

[editar] Notas

Si tanto la copia y operadores de asignación se proporcionan movimiento, la resolución de sobrecarga selecciona la asignación de movimiento si el argumento es un valor R' (ya sea' prvalue tal como un temporal sin nombre o' xValue tal como el resultado de std::move ), y selecciona la asignación de copia si el argumento es' lvalue (llamado objeto o una función / operador regresar lvalue referencia). Si sólo la asignación de copia se proporciona, de todas las categorías de argumento seleccionarlo (el tiempo que toma su argumento por valor o como referencia a const, ya que se puede unir a rvalues referencias const), lo que hace que la asignación de copia de reserva para la asignación de movimiento, cuando se mueven no está disponible .

La copia-y-swap operador de asignación

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

realiza una asignación equivalente de movimiento para los argumentos rvalue al costo de una llamada adicional al constructor movimiento de T, que a menudo es aceptable .

[editar] Ejemplo

#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);
}

Output:

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

Idioma
Conceptos
Utilidades de la biblioteca
Strings biblioteca
Contenedores biblioteca
Algoritmos biblioteca
Los iteradores biblioteca
Numéricos biblioteca
Entrada / salida de la biblioteca
Localizaciones biblioteca
Expresiones biblioteca Regular (C++11)
Operaciones de biblioteca Atómica (C++11)
Tema Biblioteca de ayuda (C++11)

cppreference.com

Buscar

Espacios de nombres

Variantes

Vistas

Acciones