In this new episode, we will focus on

the so-called default constructor.

This includes two aspects.

Firstly, what does happen when we declare an object

without associating any initialization value?

Secondly, what happens in classes where we have not

declared any explicit constructor?

Let us by begin with the first point.

A default constructor is either a constructor

without any parameter -as you can see in this example here-

or a constructor for which all parameters have default values.

We will see an example of it a litte later.

Concretely, if a constructor does not have any parameter

or has default values for all his parameters, this will mean that this

constructor can be called without initialization values.

For example, as we proceed to the declaration of a "Rectangle" object,

like this, we are not associating any initialization value

to this rectangle-type variable "r".

Concretely, this means that the initialization task will be supported

by constructor which does not need any parameter in order to function.

THIS is the default constructor.

We could imagine we wish to allow three possible ways to

initialize a rectangle of the "Rectangle" class.

That means that we are anticipating the presence of three constructors.

A constructor which does not require any parameter and will initialize

by default the height to 1 and the width to 2.

A second constructor -not by default since

it expects one parameter-

which will initialize, for example, the height to the provided value

and the width to two times the provided value.

And the third constructor, as we have seen up until now,

taking to parameter and is not a default constructor either

since its parameter list is not empty.

This constructor will initialize the height to the first provided value

and the width to the second one.

If we are using this "Rectangle" class with these three constructors together,

we now have three possible ways to declare and initialize

a rectangle, a "Rectangle"-type object.

The first we have showed you corresponds

to the call to the default constructor.

The second corresponds to a declaration such as this one,

expecting an initialization value.

In this case we would thus initialize the height to 2

and the width to 2 times 2, that is 4.

And, finally, the last possible way

is to declare a rectangle while providing two values

which obviously correspond to the

call to this constructor here, expecting two values.

Please be careful, though! Seeing the syntax

employed to call

the two-parameter constructor or the one-parameter constructor,

it could be tempting to call the default constructor

resorting to this syntax.

Declaring the "r" rectangle signifying, with a pair of empty parentheses,

that we are calling this constructor.

This is NOT the case.

In C++, this syntax does not correspond to a call to the default constructor.

If you wish to call the default constructor, you must resort to

this syntax here, without the parentheses.

By the way, if you write this, the compiler will not produce an error.

In your opinion, how does the compiler interpret this line of code?

We have just seen that a default constructor in a constructor

we can call without providing any initialization values.

This is the case of constructors with an empty parameter list.

This is also the case of constructors for which all parameters

have a default values. Here is an example thereof.

Similarly to ordinary functions or methods,

a constructor may very well have default values

for some of its parameters -or all of them, for that matter.

This constructor is a default constructor

since all its parameters have a default value.

By the way, please remember that a default values is a value

we may associate with a parameter according to this syntax

in the prototype of the function or the method.

When a function or method has a default value,

this means that we may

call this function or method without providing the value.

In this case, the default value is taken.

Concretely here, if we declare a rectangle

like this, since we have not provided any initialization value,

we will seek the default constructor of the class.

It is this one because it is possible to call this constructor

without giving it any value. In this case, it will take 1.

Concretely, this means that we will build,

thanks to this call, a rectangle

which value for the height member

will be the value provided by default here, that is 1.

Also, the value for the width member

will be two times the default value, that is 2.

By the way, please note that using default values

for the parameters has allowed us to write both previous constructors

in one single constructor.

We write a single constructor, callable with an empty list of arguments,

and this one, which is callable with an argument.

This constructor can very well be called like this.

We are declaring a variable, but, this time, precising

another value than the default value.

This means that we cannot keep the default value.

We are using the one-parameter constructor. Instead of using

the default value for "C", we wish to use the value 5.

We may call this constructor either with this syntax or this one.

You now know what a default constructor is.

Let us now focus on the second point of this sequence:

What does happen if a class does not contain any

explicitly programmed constructor?

Indeed, the initialization of such an object is so important

that we cannot do without it.

Therefoew, in C++, even if you do not declare any constructor in a class,

a basic constructor will be automatically generated.

This default constructor does not require any initialization value

and is automatically generated.

We could call it the default default constructor.

It is furnished by default if we do not declare any constructor for the class.

It is obviously a default construcor since it does not expect

any initialization value.

What will this default default constructor concretely do?

It will initialize the member attributes.

If these attributes are objects, they will be initialized

through their associated default constructors.

On the other hand, if the attributes are basic-type objects, they will remain uninitialized.

Let us take a concrete example.

Let us imagine that we are writing a "Rectangle" class

with, as attributes, a height and a width of basic types.

We could imagine that we also wish to associate another attribute

to this rectangle. This would be an object permitting

to modelize, for example, the position of the rectangle on a screen.

If we proceed to the declaration of a rectangle coded this way,

we can do so, even without any explicit constructor in the class.

That means that we will call

the default default constructor.

What does this constructor do?

It uses a minimal version of of the initialization.

The object built like this will have

its fields height and width

remain uninitialized

since they are of a basic type.

On the other hand, the position member

will have a value provided

by the default constructor of the "position" class -if the class has one.

For example, we could imagine

that the position is a two-dimensional coordinates

and that the default constructor initializes to the position (0, 0).

In this case, we would have these values here in the position attribute.

As a reminder, the basic types are the types int, double, char and bool.

However, be careful regarding default default constructors.

They have the following specificity.

As soon as we specify a specific constructor in a class,

be it a default constructor or not,

the default constructor is not provided anymore.

This concretely means that if, in a class, we specify

an explicit constructor which is not a default constructor,

then we cannot build objects of this class

without providing an explicit initialization value

for the attributes.

This typically corresponds to something we want.

When we go through the trouble of programming an explicit constructor

we do not wish C++ to sneakily add a default constructor

without our permission.

We will see later that C++ 2011 lets us, if we so desire,

reactivate the default default constructor.

We will also see with which syntax this can

signified to the compiler.

Now we will, through concrete examples, examine different variants

of constructor declaration in a same class.

We will see what these variants let us do or not

regarding the declaration- initialization of an instance.

In the A variant, the "Rectangle" class provides attributes, as before,

for the height and the width.

It could also provide other things but no

explicit constructor for this class.

In the B variant, the "Rectangle" class provides an explicitly programmed

default constructor.

This constructor will initialize

the different attributes to 0.

In the third variant, the C variant, the "Rectangle" class

provides a constructor where all the parameters have a default value.

This constructor can be explicitly called

without associating any initialization value.

In this case, 0 will be put in each attribute.

This is thus an explicitly programmed default constructor.

Finally, in the last variant, the D variant,

the "Rectangle" class provides an explicit constructor expecting

two initialization values. There is thus no explicitly programmed

default constructor in this "Rectangle" class.

Now, we will ask ourselves :

For each variant of the class, what is the default constructor?

Is this declaration syntax valid?

Is this alternative syntax for the declaration initialization of a

"Rectangle"-type object valid?

As a remainder, in the A variant, this was class schema

regarding the constructor declaration.

Here, we are not precising the attribute declaration

since it is the same for all variants.

Here, in the A variant of the "Rectangle" class, there was

not explicitly declared constructor.

This means that, regarding the default constructor in the A variant,

since there is no explicitly specified constructor,

we will have the default default constructor

which is automatically generated.

When we proceed to such a declaration of a rectangle,

we are not specifying any initialization value.

Since there is no explicit constructor in our "Rectangle" class,

the default default constructor will be called.

Also, we know that this constructor initializes things in a minimalistic way.

Here, for our height and width attributes,

since they are basic-type attributes

(they are doubles), the default default constructor

will not put any initialization values into these attributes.

Finally, our "r1" rectangle will have its members

height and width remain uninitialized.

The object exists but its attributes are not initialized.

In a class where no explicit constructor exists,

the only usable constructor is the default default constructor.

It can only be called with this syntax,

without any initialization value.

Therefore, any attempt to initialize an object

using initialization values is absolutely invalid.

Concretely, this would result in an error upon the compiling.

Let us now move on to the B variant. In the case of B,

our "Rectangle" class has its default constructor

explicitly declared.

Its task is to initialize the height and width to 0 both.

In this case, the default constructor is this the default constructor

which has been explicitly declared.

It is therefore possible to resort to this syntax which does not require

any initialization value. Unlike the previous case though,

this time, the default constructor, called here,

will properly initialize the height and width assigning them both 0.

Since there is no constructor expecting values as parameters

in the "Rectangle" class, this way to declare/initialize a rectangle object

is invalid in this case.

The C variant is a litttle bit more complex than the previous ones.

Here we have an explicitly programmed constructor

for which all parameters have a default value.

Concretely, this means that we can call this constructor

in three possible ways.

This way here signifies that we are calling the constructor

while accepting the default values.

Thus, our rectangle will have 0 and 0 as the values of its attributes.

According to this second variant,

we signify that we are taking the value 2.5 as the value of the first parameter

and that we accept the default value 0 for the second parameter.

Finally, in this last variant, it is also possible to declare a rectangle,

providing two values.

This means that we are not using the value 2.5 for this parameter

and the value 3.4 for this parameter.

In the C variant, there is thus a default constructor

which is one of the three constructors.

The one we can call with this syntax will give

the value 0 to both attributes.

Therefore, this line is clearly valid will correspond

to the initialization of both attributes to 0.

This line, corresponding to this kind of calls is obviously

valid aswell. In this case,

it will let us initialize the width to 1 and the height to 2.

For the D variant, we have, in the class, an explicit constructor

which is not a default constructor.

Its parameter list is not empty

and its parameters do not accept any default value.

As we have seen previously, as soon as an explicit constructor is programmed,

the default default constructor vanishes.

Concretely, this means that there is no default constructor

at all in this D variant.

Consequently, a declaration of this nature becomes invalid.

Of course, in this variant, it is possible to declare/initialize

a rectangle like this.

Indeed, the sole existing constructor expects two initialization values.

Ultimately, we will build here a rectangle similar to the previous one;

its height is 1, its width is 2.

As we have illustrated in the D variant, the default default

constructor ceases to exist as soon as we define

an explicit constructor in the class -be this constructor a default constructor or not.

If we wish to reactivate the default default constructor

(this is possible in C++ 2011), we need to resort to the following syntax.

We declare in the class the fact that the default constructor

will be the default variant provided by the compiler.

If, in the case of our previously seen D variant, we wish to reactivate

the default default constructor

since it had disappeared upon the declaration

of an explicit constructor,

we must clearly specify our wish.

By the way, please note that it is not particularly interesting here.

Whyso? Because we have learnt that the default default constructor

did not initialize the basic type attributes.

It is never truly recommandable to have the possibility to build an object

where certain attributes are non-initialized.

That said, in all situations where it is relevant to reactivate

the default default constructor

-typically when all the members are object-

we will have to resort to this syntax.

Reactivating a default variant is actually generalizable to other methods;

we will see other examples in upcoming episodes.

This is also generalizable for the suppression of a method;

in this case, we will use the syntax " = delete ".

For example, let us suppose that, for a given class, there is

a particular method expecting, as parameter, a double-type value.

We know that C++ let us §§store an int in a double

Normally it is thus possible to call "pas_d_int" (TN: means "no_int)

providing, as argument, an integer value.

We wish to deactivate this possibility, thus forcing "pas_d_int"

to systematically be called with a double.

In this case, we may use this clause,

thus triggering a "delete" of the method called with an int.

This will render it impossible to call the "pas_d_int" method with an integer value

as argument.

Also, please note that C++2011 lets us arrange for

a constructor to call another constructor of the same class.

This is done in the colon section.

Here, the default constructor of the "Rectangle" class calls.

in the colon section, the two-parameter constructor

of the same class.

This will let the default constructor initialize the height

and the width to 0.

Please note that this way to proceed is much better

than the previous where we reactivated

the default default constructor.

Indeed, we have seen that reactivating the default default construtor

had the disadventage of letting basic type

attributes uninitialized.

This will not be the case here.

Concluding on the initializtion, please note that, in C++11,

it is possible to assign default values to attributes

directly where they are declared.

Namely, outside any constructor.

If it so happens that a called constructor will not modify the value

of an attribute which has a default value so specified,

then this default value will be used.

Let us imagine, for example, that, in the "Rectangle" class,

we have declared a constructor

initializing the width member without doing anything for the height.

This constructor is called through such a twist.

The "r" object built this way will thus have a width member

initialized to this value through the default constructor, that is, 5.

However, nothing has been specified for the height member in the constructor.

We will thus search this value

specified here. The height will thus be 0.

Actually, it is preferable to let the constructors deal with the initialization

rather than using these tricks.

Why? Because this lets us have a clear grasp on the initialization

process only by reading the constructors.

We do not need to search for

possible default values

in a section of attribute declaration.

Voilà! This concludes our sequence on the default constructors.

We will have the chance to come back to them during the inheritance episodes.

In the meantime, you will discover new ways to build objects;

for example through the copy constructors.

Constructeurs par défaut en C++

Introduction à la programmation orientée objet (en C++)

Meet the Instructors