Move assignment operator

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

[editar] Sintaxe

[editar] Explicação

[editar] Implicitamente declarou operador de atribuição movimento

• não há construtores usuário-declarados cópia

  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.
• não há construtores usuário-declarados movimento

  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.
• não há operadores de atribuição usuário declarado de cópia

  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.
• Não existem destrutores usuário-declarados

  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.
• o operador de atribuição implicitamente declarou movimento não pode ser definido como excluído

  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.

[editar] Excluídos implicitamente declarou operador de atribuição movimento

• T tem um membro não-estático de dados que é 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 tem um não-membro estático de dados de um tipo de referência.

  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 tem um não-membro estático de dados que não podem mover-se atribuído (já excluído, inacessível, ou operador de atribuição ambígua movimento)

  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 tem classe base direta ou virtual que não podem mover-se atribuído (já excluído, inacessível, ou operador de atribuição ambígua movimento)

  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 tem um não-membro estático de dados ou uma base direta ou virtual sem um operador de atribuição movimento que não é trivial copiável.

  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 tem uma classe base direta ou indireta virtual

  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] Operador de atribuição trivial movimento

• T não tem funções de membro virtual

  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 não tem classes base virtuais

  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.
• O operador de atribuição movimento selecionado para cada base direta de T é 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.
• O operador de atribuição movimento selecionado para cada tipo de classe não-estático (ou matriz do tipo classe) memeber de T é 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.

[editar] Implicitamente definida operador de atribuição movimento

[editar] Notas

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

[editar] Exemplo

#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