Copy assignment operator – cppreference.com

Original:

A copy 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, T&, const T&, volatile T&, or const volatile T&. A type with a public copy assignment operator is CopyAssignable.

The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.

Original:

# Typical declaration of a copy assignment operator when copy-and-swap idiom can be used

The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.

Original:

# Typical declaration of a copy assignment operator when copy-and-swap idiom cannot be used

The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.

Original:

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

The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.

Original:

# Avoiding implicit copy assignment

The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.

Original:

The copy assignment operator is called whenever selected by Überlast Auflösung, e.g. when an object appears on the left side of an assignment expression.

The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.

Original:

If no user-defined copy assignment operators are provided for a class type (struct, class, or union), the compiler will always declare one as an inline public member of the class. This implicitly-declared copy assignment operator has the form T& T::operator=(const T&) if all of the following is true:

The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.

Original:

Otherwise the implicitly-declared copy assignment operator is declared as T& T::operator=(T&). (Note that due to these rules, the implicitly-declared copy assignment operator cannot bind to a volatile lvalue argument)

The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.

Original:

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

The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.

Original:

Because the copy assignment operator 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.

The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.

Original:

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

The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.

Original:

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

The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.

Original:

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

The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.

Original:

If the implicitly-declared copy 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 copy assignment copies the object representation (as by std::memmove). For non-union class types (class and struct), the operator performs member-wise copy assignment of the object's bases and non-static members, in their initialization order, using, using built-in assignment for the scalars and copy assignment operator for class types.

The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.

Original:

The generation of the implicitly-defined copy assignment operator is deprecated(seit C++11) if T has a user-declared destructor or user-declared copy constructor.

The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.

Original:

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.

The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.

Original:

Copy assignment operator can be expressed in terms of copy constructor, destructor, and the swap() member function, if one is provided:

The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.

Original:

For non-throwing swap(), this form provides starke Ausnahme Garantie. For rvalue arguments, this form automatically invokes the move constructor, and is sometimes referred to as "unifying assignment operator" (as in, both copy and move).

The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.

#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