In the C++ programming language, a copy constructor is a special constructor for creating a new object as a copy of an existing object. Copy constructors are the standard way of copying objects in C++, as opposed to cloning, and have C++-specific nuances.
The first argument of such a constructor is a reference to an object of the same type as is being constructed (const or non-const), which might be followed by parameters of any type (all having default values).
Normally the compiler automatically creates a copy constructor for each class (known as an implicit copy constructor) but for special cases the programmer creates the copy constructor, known as a user-defined copy constructor. In such cases, the compiler does not create one. Hence, there is always one copy constructor that is either defined by the user or by the system.
A user-defined copy constructor is generally needed when an object owns pointers or non-shareable references, such as to a file, in which case a destructor and an assignment operator should also be written (see Rule of three).
Copying of objects is achieved by the use of a copy constructor and an assignment operator. A copy constructor has as its first parameter a (possibly const or volatile) reference to its own class type. It can have more arguments, but the rest must have default values associated with them.[1] The following would be valid copy constructors for class X
:const
object:X&
form of the copy constructor is used when it is necessary to modify the copied object. This is very rare but it can be seen used in the standard library's [[std::auto_ptr]]
. A reference must be provided:copy_from_me
is not passed as reference (&
) :
The following cases may result in a call to a copy constructor:
These cases are collectively called copy-initialization and are equivalent to:[2] T x = a;
It is however, not guaranteed that a copy constructor will be called in these cases, because the C++ Standard allows the compiler to optimize the copy away in certain cases, one example being the return value optimization (sometimes referred to as RVO).
An object can be assigned value using one of the two techniques:
An object can be initialized by any one of the following ways.
a. Through declaration
The copy constructor is used only for initializations, and does not apply to assignments where the assignment operator is used instead.
The implicit copy constructor of a class calls base copy constructors and copies its members by means appropriate to their type. If it is a class type, the copy constructor is called. If it is a scalar type, the built-in assignment operator is used. Finally, if it is an array, each element is copied in the manner appropriate to its type.[3]
By using a user-defined copy constructor the programmer can define the behavior to be performed when an object is copied.
These examples illustrate how copy constructors work and why they are sometimes required.
Consider the following example:
class Person ;
int main
Output 10 15 10 23 15 10
As expected, timmy
has been copied to the new object, timmy_clone
. While timmy
's age was changed, timmy_clone
's age remained the same. This is because they are totally different objects.
The compiler has generated a copy constructor for us, and it could be written like this:
Consider a very simple dynamic array class like the following:
class Array ;
int main Output 25 25 Segmentation fault
Since we did not specify a copy constructor, the compiler generated one for us. The generated constructor would look something like:
If we write our own copy constructor that performs a deep copy then this problem goes away.
Array(const Array& other) : size(other.size), data(new int[other.size]) Here, we are creating a new int array and copying the contents to it. Now, other's destructor deletes only its data, and not first's data. Line (2) will not produce a segmentation fault anymore.
Instead of doing a deep copy right away, there are some optimization strategies that can be used. These allow you to safely share the same data between several objects, thus saving space. The copy-on-write strategy makes a copy of the data only when it is written to. Reference counting keeps the count of how many objects are referencing the data, and will delete it only when this count reaches zero (e.g. boost::shared_ptr
).
There is no such thing as "bitwise copy constructor" in C++. However, the default generated copy constructor copies by invoking copy constructors on members, and for a raw pointer member this will copy the raw pointer (i.e. not a deep copy).
A logical copy constructor makes a true copy of the structure as well as its dynamic structures. Logical copy constructors come into the picture mainly when there are pointers or complex objects within the object being copied.
An explicit copy constructor is one that is declared explicit by using the explicit keyword. For example: