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

[Bearbeiten] Syntax

[Bearbeiten] Erklärung

[Bearbeiten] Implizit deklarierte Zuweisungsoperator

• Jede direkte Basis B der T hat einen Zuweisungsoperator, deren Parameter B oder const B& oder 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.
• jede nicht-statische Daten Mitglied M der T der Klasse-Typ oder ein Array von Klasse-Typ hat eine Kopie Zuweisungsoperator deren Parameter M oder const M& oder 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.

[Bearbeiten] Gelöschte implizit deklariert Zuweisungsoperator

• T einen nicht-statisches Datenelement, das const ist

  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 hat eine nicht-statische Daten Mitglied einer Referenz-Typ .

  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 hat eine nicht-statische Daten Mitglied, die nicht kopiergeschützt zugeordnet werden können (gelöscht hat, unzugänglich oder mehrdeutig Zuweisungsoperator)

  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 hat direkte oder virtuelle Basisklasse, die nicht kopiergeschützt zugeordnet werden können (gelöscht hat, unzugänglich oder mehrdeutig move Zuweisungsoperator)

  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 verfügt über eine benutzerfreundliche erklärt move Konstruktor

  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 verfügt über eine benutzerfreundliche erklärt move Zuweisungsoperator

  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.

[Bearbeiten] Trivial Zuweisungsoperator

• T hat keine virtuelle Member-Funktionen

  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 hat keine virtuellen Basisklassen

  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.
• Der Zuweisungsoperator für jede direkte Basis von T gewählt ist 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.
• Der Zuweisungsoperator für jeden nicht-statische Klasse-Typ (oder ein Array von Klasse-Typ) memeber der T gewählt ist 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.

[Bearbeiten] Zuweisungsoperator implizit definiert

[Bearbeiten] Notes

[Bearbeiten] Kopieren und tauschen

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

[Bearbeiten] Beispiel

#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