Default constructor

If you do not declare any constructors in a class definition, the compiler assumes the class to have a default constructor with no arguments. Therefore, after declaring a class like this one:

1 2 3 4 5

class CExample { public: int a,b,c; void multiply (int n, int m) { a=n; b=m; c=a*b; } };

The compiler assumes that CExample has a default constructor, so you can declare objects of this class by simply declaring them without any arguments:

CExample ex;

But as soon as you declare your own constructor for a class, the compiler no longer provides an implicit default constructor. So you have to declare all objects of that class according to the constructor prototypes you defined for the class:

1 2 3 4 5 6

class CExample { public: int a,b,c; CExample (int n, int m) { a=n; b=m; }; void multiply () { c=a*b; }; };

Here we have declared a constructor that takes two parameters of type int. Therefore the following object declaration would be correct:

CExample ex (2,3);

But,

CExample ex;

Would not be correct, since we have declared the class to have an explicit constructor, thus replacing the default constructor.

But the compiler not only creates a default constructor for you if you do not specify your own. It provides three special member functions in total that are implicitly declared if you do not declare your own. These are the copy constructor, the copy assignment operator, and the default destructor.

The copy constructor and the copy assignment operator copy all the data contained in another object to the data members of the current object. For CExample, the copy constructor implicitly declared by the compiler would be something similar to:

1 2 3

CExample::CExample (const CExample& rv) { a=rv.a; b=rv.b; c=rv.c; }

Therefore, the two following object declarations would be correct:

1 2	CExample ex (2,3); CExample ex2 (ex); // copy constructor (data copied from ex)