Copy 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 de cópia

• cada base direta B de T tem um operador de atribuição de cópia cujos parâmetros são B ou const B& ou const volatile B&

  Original:

  each direct base B of T has a copy assignment operator whose parameters are B or const B& or const volatile B&

  The text has been machine-translated via Google Translate.
  You can help to correct and verify the translation. Click here for instructions.
• cada membro não-estático dados M de T de tipo de classe ou série de tipo de classe tem um operador de atribuição de cópia cujos parâmetros são M ou const M& ou const volatile M&

  Original:

  each non-static data member M of T of class type or array of class type has a copy assignment operator whose parameters are M or const M& or const volatile M&

  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 de cópia

• 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-estático membro de dados que não pode ser cópia atribuído (já excluído, operador de atribuição inacessível, ou ambígua cópia)

  Original:

  T has a non-static data member that cannot be copy-assigned (has deleted, inaccessible, or ambiguous copy 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 pode ser cópia 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 copy-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 usuário declarou construtor movimento

  Original:

  T has a user-declared move constructor

  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 usuário declarou operador de atribuição movimento

  Original:

  T has a user-declared 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.

[editar] Operador de atribuição Trivial cópia

• 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 de cópia selecionado para cada base direta de T é trivial

  Original:

  The copy 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 de cópia selecionado para cada tipo de classe não-estático (ou matriz do tipo classe) memeber de T é trivial

  Original:

  The copy 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 operador definido atribuição de cópia

[editar] Notas

[editar] Copie e trocar

T& T::operator=(T arg) { // copy/move constructor is called to construct arg
    swap(arg);    // resources exchanged between *this and arg
    return *this;
}  // destructor is called to release the resources formerly held by *this

[editar] Exemplo

#include <iostream>
#include <memory>
struct A {
    int n;
    std::string s1;
    // user-defined copy assignment, copy-and-swap form
    A& operator=(A other) {
        std::cout << "copy assignment of A\n";
        std::swap(n, other.n);
        std::swap(s1, other.s1);
        return *this;
    }
};
 
struct B : A {
    std::string s2;
    // implicitly-defined copy assignment
};
 
struct C {
     std::unique_ptr<int[]> data;
     std::size_t size;
     // non-copy-and-swap assignment
     C& operator=(const C& other) {
         // check for self-assignment
         if(&other == this)
             return *this;
         // reuse storage when possible
         if(size != other.size)
             data.reset(new int[other.size]);
         std::copy(&other.data[0],
                   &other.data[0] + std::min(size, other.size),
                   &data[0]);
         return *this;
     }
     // note: copy-and-swap would always cause a reallocation
};
 
int main()
{
    A a1, a2;
    std::cout << "a1 = a2 calls ";
    a1 = a2; // user-defined copy assignment
 
    B b1, b2;
    b2.s1 = "foo";
    b2.s2 = "bar";
    std::cout << "b1 = b2 calls ";
    b1 = b2; // implicitly-defined copy assignment
    std::cout << "b1.s1 = " << b1.s1 << " b1.s2 = " << b1.s2 <<  '\n';
}

a1 = a2 calls copy assignment of A
b1 = b2 calls copy assignment of A
b1.s1 = foo b1.s2 = bar