Copy constructors

 

C++

Language

Standard library headers

Concepts

Utilities library

Strings library

Containers library

Algorithms library

Iterators library

Numerics library

Input/output library

Localizations library

Regular expressions library (C++11)

Atomic operations library (C++11)

Thread support library (C++11)

Filesystem library (C++17)

Technical Specifications

 

C++ language

 

Classes

General

overview

class/struct types

union types

Members

data members

static members

the this pointer

nested classes

member templates

bit fields

using-declarations

member functions

member access specifiers

constructors and member initializer lists

default member initializer(C++11)

friend specifier

explicit specifier

converting constructor

Special member functions

default constructor

copy constructor

move constructor(C++11)

copy assignment operator

move assignment operator(C++11)

destructor

Inheritance

base and derived classes

virtual member functions

override(C++11)

final(C++11)

pure virtual functions and abstract classes

 

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.

Syntax

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

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.

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)

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)

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.

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)

Notes

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