What is explicit copy constructor?

Answer 1

An explicit constructor is one that is declared explicit and thus prevents implicit construction of an object. To understand explicit construction you must first understand implicit construction.

Consider the following code that uses a simple class, Square, to compute the square of any given integer:

#include

using namespace std;

class Square

{

private:

int m_number;

public:

Square(int number):m_number(number*number){}

friend void display(Square square);

};

void display(Square square)

{

cout << "Number = " << square.m_number << endl;

}

int main()

{

Square ten(10); // Explicit construction

Square twenty=20; // Implicit construction

display(ten);

display(twenty);

display(30); // What does this mean?

return(0);

}

Output:

Number = 100

Number = 400

Number = 900

Although there's nothing intrinsically wrong with the line display(30), it's not exactly clear to the reader what this line does. The display() function clearly expects an instance of a Square object, yet we're passing a literal constant.

The clue is the implicit constructor call, Square twenty = 20. Although we declared no assignment operator that accepts a literal constant, the statement implies we call the constructor, Square(int). In other words, the line is equivalent to explicitly calling Square twenty(20).

This is really no different to the way primitives work. That is, int x=5 is the same as calling int x(5), but the former is a more natural form of assignment. However, this behaviour is not always desirable. While Square twenty=5 may be fine, the unwanted side effect is that it also allows us to make ambiguous calls, like display(30).

Although the line display(30) forces the display()function to construct a local Square object using implicit construction, it's not obvious to the reader that an object is created (and subsequently destroyed), and as a result of this it isn't obvious to the reader why display(30) would produce the result Number = 900.

Note that while this usage may well be obvious to the developer while writing the code, when the developer revisits the code later, it may not be quite so obvious. And if the developer has trouble reading their own code, you can imagine how difficult it would be for a third party to understand the same code.

To avoid this problem, we must declare the constructor to be explicit:

explicit Square( int number ):m_number(number*number){}

As soon as we do this, the lines Square twenty = 20 and display(30) become invalid. To rectify this, we must replace them with calls to the explicit constructor instead:

int main()

{

Square ten(10); // Explicit constructor

Square twenty(20); // Explicit constructor

display(ten);

display(twenty);

display(Square(30)); // Explicit constructor

return(0);

}

Now it is much clearer to the reader what's going on. Although we've lost the ability to implicitly construct a Squareobject, we've assured our code remains readable at all times by enlisting the help of the compiler to ensure that we never unintentionally construct a Square object via implication.

Answer 2

There is no such thing as an explicit copy constructor. Explicit constructors are required when we wish to prevent narrowing through implicit conversion of argument values, but a copy constructor's argument is a constant reference to an existing object of the same type, thus there is no implicit conversion and therefore no narrowing. That is, copying an object of type T or of a type derived from type T will always create a new object of type T. If we want to copy a type derived from a T, then we need to invoke that derived type's copy constructor, not the copy constructor for a T.

Answer 3

It means that it is explicitly written out - as opposed to the implicit constructor, which is created automatically in some programming languages, when you don't provide one.