Question

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.

• When one object explicitly initializes another, such as in a declaration
• When a copy of an object is made to be passed to a function
• When a temporary object is generated (most commonly, as a return value)

Answer 1

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