Copy constructor

From Wikipedia, the free encyclopedia

Jump to: navigation, search A copy constructor is a special constructor in the C++ programming language used to create a new object as a copy of an existing object. 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 a default 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. A user-defined copy constructor is generally needed when an object owns pointers or nonshareable references, such as to a file, in which case a destructor and an assignment operator should also be written (see Rule of three).

Contents
[hide]

1 Definition 2 Operation o 2.1 Explicit assignment in an expression o 2.2 Initialization 3 Examples o 3.1 Implicit copy constructor o 3.2 User-defined copy constructor o 3.3 Copy constructors and templates 4 Explicit copy constructor 5 See also 6 Notes

[edit] Definition 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:
X X X X X X (const X& copy_from_me); (X& copy_from_me); (const volatile X& copy_from_me); (volatile X& copy_from_me); (const X& copy_from_me, int = 10); (const X& copy_from_me, double = 1.0,

int = 40);

The first one should be used unless there is a good reason to use one of the others. One of the differences between the first and the second is that temporaries can be copied with the first. For example:
X a = X(); // valid if you have X (const X& copy_from_me) but not valid if you have X (X& copy_from_me) // because the second wants a non-const X& // to create a, the compiler first creates a temporary by invoking the default constructor // of X, then uses the copy constructor to initialize a as a copy of that temporary. // However, for some compilers both the first and the second actually work.

Another difference between them is the obvious:

X const a; X b = a; // valid if you have X (const X& copy_from_me) but not valid if you have X (X& copy_from_me) // because the second wants a non-const X&

The 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:
X a; X b = a; // valid if any of the copy constructors are defined // since you're passing in a reference

The following are invalid copy constructors (Reason - copy_from_me is not passed as reference) :
X (X copy_from_me); X (const X copy_from_me);

because the call to those constructors would require a copy as well, which would result in an infinitely recursive call. The following cases may result in a call to a copy constructor: 1. 2. 3. 4. 5. When an object is returned by value When an object is passed (to a function) by value as an argument When an object is thrown When an object is caught When an object is placed in a brace-enclosed initializer list

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).

[edit] Operation
An object can be assigned value using one of the two techniques:

Explicit assignment in an expression Initialization

[edit] Explicit assignment in an expression

Object A; Object B; A = B; // translates as Object::operator=(const Object&), thus A.operator=(B) is called // (invoke simple copy, not copy constructor!)

[edit] Initialization
An object can be initialized by any one of the following ways. a. Through declaration
Object B = A; // translates as Object::Object(const Object&) (invoke copy constructor)

b. Through function arguments

type function (Object a);

c. Through function return value

Object a = function();

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.

[edit] Examples
These examples illustrate how copy constructors work and why they are required sometimes.

[edit] Implicit copy constructor

Let us consider the following example.

//copy constructor #include <iostream> class Person { public: int age; explicit Person (int age) : age (age) {} };

int main()
{ Person timmy (10); Person sally (15); Person timmy_clone = timmy; std::cout << timmy.age << " " << sally.age << " " << timmy_clone.age << std::endl; timmy.age = 23; std::cout << timmy.age << " " << sally.age << " " << timmy_clone.age << std::endl; return 0; }

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:
Person (const Person& copy) : age (copy.age) {}

So, when do we really need a user-defined copy constructor? The next section will explore that question.

[edit] User-defined copy constructor

Now, consider a very simple dynamic array class like the following:
#include <iostream> class Array { public: int size;

int* data;
explicit Array (int size) : size (size), data (new ~Array() { delete[] data; } };

int[size]) {}

int main()
{ Array first (20); first.data[0] = 25; { Array copy = first; std::cout << first.data[0] << " " << copy.data[0] << std::endl; } // (1) // (2)

first.data[0] = 10; return 0; }

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:
Array (const Array& copy) : size (copy.size), data (copy.data) {}

The problem with this constructor is that it performs a shallow copy of the data pointer. It only copies the address of the original data member; this means they both share a pointer to the same chunk of memory, which is not what we want. When the program reaches line (1), copy's destructor gets called (because objects on the stack are destroyed automatically when their scope ends). Array's destructor deletes the data array of the original, therefore when it deleted copy's data, because they share the same pointer, it also deleted first's data. Line (2) now accesses invalid data and writes to it! This produces the infamous segmentation fault. If we write our own copy constructor that performs a deep copy then this problem goes away.
Array(const Array& copy) : size(copy.size), data(new int[copy.size]) { std::copy(copy.data, copy.data + copy.size, data); <algorithm> for std::copy }

// #include

Here, we are creating a new int array and copying the contents to it. Now, copy's destructor only deletes its data and not first's data as well. 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).

[edit] Copy constructors and templates

Contrary to expectations, a template copy constructor is not a user-defined copy constructor. Thus it is not enough to just have:
template <typename A> Array::Array (const A& copy) : size (copy.size()), data (new int[copy.size()]) { std::copy (copy.begin(), copy.end(), data); }

(Note that the type of A can be Array.) A user-defined, non-template copy constructor must also be provided for construction of Array from Array.

[edit] Explicit copy constructor

An explicit copy constructor is one that is declared explicit by using the explicit keyword. For example:
explicit X (const X& copy_from_me);

It is used to prevent copying of objects at function calls or with the copy-initialization syntax.

[edit] See also

Assignment operator in C++ Object copy

[edit] Notes
1. ^ INCITS ISO IEC 14882-2003 12.8.2. [1] 2. ^ ISO/IEC (2003). ISO/IEC 14882:2003(E): Programming Languages - C++ 8.5 Initializers [dcl.init] para. 12 3. ^ INCITS ISO IEC 14882-2003 12.8.8. [2]

Retrieved from "http://en.wikipedia.org/wiki/Copy_constructor" Categories: C++ | Method (computer science) | Articles with example C++ code
Personal tools

Log in / create account

Namespaces

Article Discussion

Variants Views Actions Search

Read Edit View history

Navigation

Main page Contents Featured content Current events Random article Donate to Wikipedia

Interaction Toolbox

Help About Wikipedia Community portal Recent changes Contact Wikipedia

What links here Related changes Upload file Special pages Permanent link Cite this page

Print/export

Create a book

Download as PDF Printable version

Languages

Deutsch This page was last modified on 4 February 2011 at 11:29. Text is available under the Creative Commons Attribution-ShareAlike License; additional terms may apply. See Terms of Use for details. Wikipedia is a registered trademark of the Wikimedia Foundation, Inc., a non-profit organization. Contact us Privacy policy About Wikipedia Disclaimers