CODEWITHSUNDEEP
c++copy-constructor
Ravi Gupta
Ravi Gupta

Reputation: 6460

Copy constructor with more than one parameter

I am learning C++ and was reading copy constructor from the C++: The Complete Reference. The books says that

It is permissible for a copy constructor to have additional parameters as long as they have default arguments defined for them. However, in all cases the first parameter must be a reference to the object doing the initializing.

But I am confused that how we are going to pass those additional parameters? I am sure there should be some way which is not given in the book and which I am unable to figure out. Can anyone help me out?

EDIT: Also is it possible to pass these extra parameters in all three cases i.e.

Upvotes: 9

Views: 4353

Answers (2)

jxh
jxh

Reputation: 70412

Here is a simple example:

class A {
    //...
public:
    A (const A&, bool deep = false) {
        if (!deep) { /* make a shallow copy */ }
        else { /* make a deep copy */ }
    }
};

void foo (A x) { /*...*/ }
A bar () { /*...*/ return A(); }
A a_var;

In this example, the parameter is defaulted to false, meaning the default copy constructor will be shallow.

A b(a_var);       // b gets a shallow copy of a
foo(b);           // foo() receives a shallow copy

However, it would be possible to effect a deep copy by passing in true in the second parameter.

A b(a_var, true); // b gets a deep copy of a
foo(A(b, true));  // foo receives a shallow copy of a deep copy

Similarly, for a function returning an A, the returned copy would be shallow, since it is using the default, but the receiver can make it deep when it receives it.

A b(bar());       // shallow
A b(bar(), true); // deep

Remember when you define a copy constructor, it is likely to mean you will need to define a destructor and overload the assignment operator (the rule of three).

Upvotes: 13

user1084944
user1084944

Reputation:

Think of it this way: there is only the notion of constructor. When the compiler decides a copy needs to be made, it looks for a constructor that can be called by passing in a single object of type T. Because of this special use case, we conventionally call the constructor chosen a "copy" constructor.

Upvotes: 1

Related Questions