C++ for Scientists - Technische Universität Dresden

3.3. CONSTRUCTORS 71
Advise
Define a default constructor for where it is possible although it might not
seem necessary when you implement the class.
For the complex class, we might think that we do not need a default constructor because we
can delay its declaration until we know its value. The absence of a default constructor creates
(at least) two problems:
• We might need the variable outside the scope in which the values are computed. For
instance, if the value depends on some condition and we would declare the (complex)
variable in the two branches of if, the variable would not exist after the if.
• We build containers of the type, e.g. a matrix of complex values. Then the constructor of
the matrix must call constructors of complex for each entry and the default constructor
is the most convenient fashion to handle this.
For some classes, it might be very difficult to define a default constructor, e.g. when some of
the members are references. In those cases, it can be easier to accept the before-mentioned
drawbacks instead of building badly designed default constructors.
We can combine all three of them with default arguments:
class complex
{
public:
complex(double r= 0, double i= 0) : r(r), i(i) {}
// ...
};
In the previous main function we defined two objects, one a copy of the other. We can write a
constructor for this — called copy constructor:
class complex
{
public:
complex(const complex& c) : i(c.i), r(c.r) {}
// ...
};
But we do not have to. C ++ is doing this itself. If we do not define a copy constructor, i.e. a
construstor that has one argument and which is a const reference to its type, than the compiler
creates this construstor implicitly. This automatically built copies each member variable by
calling the variables’ copy constructors and this is exactly what we did. In cases like this where
copying all members is precisely what you want for your copy constructor you should use the
default for the following reasons:
• It is less verbose;
• It is less error-prone;
• Other people know directly what your copy constructor does without reading your code;
and