What is copy construct in c plus plus?

Answer 1

A copy constructor is a separate, compiler created constructor for a class. This allows the programmer to instantiate a class and copy the contents of the given class into the new class. For example:

If I have a class foobar:

Foobar foobar;

Foobar foobar1( foobar );

The second line creates a class in the exact image of the original class, with all of its variables set the same way as the original class.

Answer 2

A copy constructor is a special constructor that constructs a new object from an existing object of the same type, thus creating a copy. It works in a similar manner to the following:

int x = 42;

int y = x;

Here, y is an exact copy of x -- they both have the same value, but they are completely independent of one another.

Copy construction typically takes place when passing objects into functions by value, or returning values from functions. For instance:

int square (int x) { return x*x; }

Here, x is a copy of whatever integer we pass to the function, thus x is copy-constructed. The return value is also copy constructed.

Built-in types such as int are not implemented as objects, of course, so they have no constructors. However, when we define our own classes we invariably need to provide a similar means of copying objects. That is the role of the copy constructor.

Even if you do not define a copy constructor, one is generated for you by the compiler. The default behaviour of the compiler-generated copy constructor is to perform a member-wise copy of the class members. In most cases this is fine, however if your class contains a pointer to a resource you will want to override the default behaviour because a member-wise copy would simply copy the pointer (a shallow copy), not what it points at (a deep copy).

For instance, the following class declares a pointer member:

struct foo

{

int* p;

foo (): p {new int{42}} {}

~foo () { delete p; }

};

Let's create an instance of foo:

foo a;

Now consider what happens when we copy that instance:

foo b = a;

assert (a.p b.p);

Again, the compiler-generated version of the copy assignment would result in both objects pointing at the same memory through member-wise copy. Worse still, it would also create a memory leak because the original memory pointed to by b.p was not released. So we must define our own copy assignment operator to perform a deep copy:

struct foo

{

int* p;

foo (): p {new int{42}} {}

foo (const foo& f): p {new int {*f.p}} {} // copy constructor

foo& operator= (const foo& f) {*p = f.p; return *this; } // copy assign

~foo () { delete p; }

};

As well as copy construct and assign, we should also cater for move construct and assign:

struct foo

{

int* p;

foo (): p {new int{42}} {}

foo (const foo& f): p {new int {*f.p}} {} // copy constructor

foo& operator= (const foo& f) {*p = f.p; return *this; } // copy assign

foo (foo&& f): p {f.p}} {f.p=nullptr;} // move constructor

foo& operator= (foo&& f) { int* t = p; p = f.p; f.p=t; return *this; } // move assign

~foo () { delete p; }

};

Note that with move constructor, we take ownership of the incoming memory and nullify the incoming pointer. With move assign we simply swap the pointers. This is because when a move is invoked, we must take ownership of the incoming resources whilst leaving the incoming object in a state that allows it to be destroyed.

Answer 3

A copy constructor is a special constructor that constructs a new object from an existing object of the same type, thus creating a copy. It works in a similar manner to the following:

int x = 42;

int y = x;

Here, y is an exact copy of x -- they both have the same value, but they are completely independent of one another.

Copy construction typically takes place when passing objects into functions by value, or returning values from functions. For instance:

int square (int x) { return x*x; }

Here, x is a copy of whatever integer we pass to the function, thus x is copy-constructed. The return value is also copy constructed.

Built-in types such as int are not implemented as objects, of course, so they have no constructors. However, when we define our own classes we invariably need to provide a similar means of copying objects. That is the role of the copy constructor.

Even if you do not define a copy constructor, one is generated for you by the compiler. The default behaviour of the compiler-generated copy constructor is to perform a member-wise copy of the class members. In most cases this is fine, however if your class contains a pointer to a resource you will want to override the default behaviour because a member-wise copy would simply copy the pointer (a shallow copy), not what it points at (a deep copy).

For instance, the following class declares a pointer member:

struct foo

{

int* p;

foo (): p {new int{42}} {}

~foo () { delete p; }

};

Let's create an instance of foo:

foo a;

Now consider what happens when we copy that instance:

foo b = a;

assert (a.p b.p);

Again, the compiler-generated version of the copy assignment would result in both objects pointing at the same memory through member-wise copy. Worse still, it would also create a memory leak because the original memory pointed to by b.p was not released. So we must define our own copy assignment operator to perform a deep copy:

struct foo

{

int* p;

foo (): p {new int{42}} {}

foo (const foo& f): p {new int {*f.p}} {} // copy constructor

foo& operator= (const foo& f) {*p = f.p; return *this; } // copy assign

~foo () { delete p; }

};

As well as copy construct and assign, we should also cater for move construct and assign:

struct foo

{

int* p;

foo (): p {new int{42}} {}

foo (const foo& f): p {new int {*f.p}} {} // copy constructor

foo& operator= (const foo& f) {*p = f.p; return *this; } // copy assign

foo (foo&& f): p {f.p}} {f.p=nullptr;} // move constructor

foo& operator= (foo&& f) { int* t = p; p = f.p; f.p=t; return *this; } // move assign

~foo () { delete p; }

};

Note that with move constructor, we take ownership of the incoming memory and nullify the incoming pointer. With move assign we simply swap the pointers. This is because when a move is invoked, we must take ownership of the incoming resources whilst leaving the incoming object in a state that allows it to be destroyed.