##### cppreference.com

##### Search

Create account

##### Namespaces

- Page
- Discussion

##### Variants

##### Views

- View
- Edit
- History

##### Actions

# Copy constructors

From cppreference.com
< cpp‎ | language

A copy constructor of class `T` is a non-template constructor whose first parameter is T&, const T&, volatile T&, or const volatile T&, and either there are no other parameters, or the rest of the parameters all have default values.

### [edit] Syntax

class_name ( const class_name `&` ) | (1) |
class_name ( const class_name `&` ) = default; | (2) |
class_name ( const class_name `&` ) = delete; | (3) |

### [edit] Explanation

1. Typical declaration of a copy constructor.
2. Forcing a copy constructor to be generated by the compiler.
3. Avoiding implicit generation of the copy constructor.

The copy constructor is called whenever an object is initialized (by direct-initialization or copy-initialization) from another object of the same type (unless overload resolution selects a better match or the call is elided), which includes

- initialization: T a = b; or T a(b);, where b is of type `T`;
- function argument passing: f(a);, where `a` is of type `T` and `f` is void f(T t);
- function return: return a; inside a function such as T f(), where `a` is of type `T`, which has no move constructor.

### [edit] Implicitly-declared copy constructor

If no user-defined copy constructors are provided for a class type (struct, class, or union), the compiler will always declare a copy constructor as a non-explicit `inline public` member of its class. This implicitly-declared copy constructor has the form T::T(const T&) if all of the following are true:

- each direct and virtual base `B` of `T` has a copy constructor whose parameters are B or const B& or const volatile B&;
- each non-static data member `M` of `T` of class type or array of class type has a copy constructor whose parameters are M or const M& or const volatile M&.

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

A class can have multiple copy constructors, e.g. both T::T(const T&) and T::T(T&). If some user-defined copy constructors are present, the user may still force the generation of the implicitly declared copy constructor with the keyword `default`. | (since C++11)

The implicitly-declared (or defaulted on its first declaration) copy constructor has an exception specification as described in dynamic exception specification (until C++17)exception specification (since C++17)

### [edit] Deleted implicitly-declared copy constructor

The implicitly-declared copy constructor for class `T` is undefined if any of the following conditions are true: | (until C++11)
The implicitly-declared or defaulted copy constructor for class `T` is defined as deleted if any of the following conditions are true: | (since C++11)

- `T` has non-static data members that cannot be copied (have deleted, inaccessible, or ambiguous copy constructors);
- `T` has direct or virtual base class that cannot be copied (has deleted, inaccessible, or ambiguous copy constructors);
- `T` has direct or virtual base class with a deleted or inaccessible destructor;

`T` has a user-defined move constructor or move assignment operator; `T` is a union and has a variant member with non-trivial copy constructor; `T` has a data member of rvalue reference type. | (since C++11)

### [edit] Trivial copy constructor

The copy constructor for class `T` is trivial if all of the following are true:

- it is not user-provided (that is, it is implicitly-defined or defaulted), and if it is defaulted, its signature is the same as implicitly-defined (until C++14);
- `T` has no virtual member functions;
- `T` has no virtual base classes;
- the copy constructor selected for every direct base of `T` is trivial;
- the copy constructor selected for every non-static class type (or array of class type) member of `T` is trivial;

A trivial copy constructor creates a bytewise copy of the object representation of the argument, and performs no other action. `TriviallyCopyable` objects can be copied by copying their object representations manually, e.g. with std::memmove. All data types compatible with the C language (POD types) are trivially copyable.

### [edit] Implicitly-defined copy constructor

If the implicitly-declared copy constructor is neither deleted nor trivial, it is defined (that is, a function body is generated and compiled) by the compiler if odr-used. For union types, the implicitly-defined copy constructor copies the object representation (as by std::memmove). For non-union class types (class and struct), the constructor performs full member-wise copy of the object's bases and non-static members, in their initialization order, using direct initialization.

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

### [edit] Notes

In many situations, copy constructors are optimized out even if they would produce observable side-effects, see copy elision.

### [edit] Example

    struct A
    {
        int n;
        A(int n = 1) : n(n) { }
        A(const A& a) : n(a.n) { } // user-defined copy ctor
    };

    struct B : A
    {
        // implicit default ctor B::B()
        // implicit copy ctor B::B(const B&)
    };

    struct C : B
    {
         C() : B() { }
     private:
         C(const C&); // non-copyable, C++98 style
    };

    int main()
    {
        A a1(7);
        A a2(a1); // calls the copy ctor
        B b;
        B b2 = b;
        A a3 = b; // conversion to A& and copy ctor
        volatile A va(10);
        // A a4 = va; // compile error

        C c;
        // C c2 = c; // compile error
    }

### [edit] Defect reports

The following behavior-changing defect reports were applied retroactively to previously published C++ standards.

DR | Applied to | Behavior as published | Correct behavior
--- | --- | --- | ---
CWG 2171 | C++14 | X(X&) = default was non-trivial | made trivial
CWG 496 | C++11 | structs with volatile members were trivially copyable | volatile members make copy non-trivial
CWG 2094 | C++14 | volatile members make copy non-trivial | structs with volatile members are trivially copyable

Retrieved from "http://en.cppreference.com/mwiki/index.php?title=cpp/language/copy_constructor&oldid=91794"
Hidden category:

- Pages with unreviewed CWG DR marker