Constructors

A constructor is used to create an instance of a class (i.e., an object). It is a special kind of function with a special job.

The Constructor's Job

The constructor's job is to initialize the object and make it ready for use. The memory the constructor is initializing has already been allocated (e.g., at the opening curly brace of the function), but until the constructor runs, the memory has not yet been initialized.

Thus, the constructor's main job is to initialize the data members of the object being constructed. (Although it can do other things as well.)

Parameterized Constructors

A parameterized constructor is exactly what it sounds like: a constructor that has parameters.

class Cow {
  public:
    // We can only have a Cow if we know
    // how many spots it has and how old it is
    Cow(int numSpots, int age);
    Cow() = delete;
...

A parameterized constructor must be explicitly invoked. For example, here are two highlighted lines from main.cpp that invoke the parameterized constructor of Cow:

int main() {
    Cow bessie{3, 12};
    const Cow mabel{1, 2};

The Default Constructor (No Parameters)

A constructor with no parameters has a special name: the default constructor.

This constructor can be invoked explicitly as

Sheep mead{};

Default Initialization Uses the Default Constructor

But also, and maybe more importantly, the default constructor is the constructor used for default initialization. For instance,

Sheep mead;

would also invoke the default constructor of class Sheep to initialize mead.

Default initialization comes up in many contexts and sometimes it can be subtle. For example,

Sheep herd[10];

creates an array of ten Sheep objects. How are they initialized? Using the default constructor!

So that one line of code actually calls Sheep's default constructor ten times.

The Default Constructor Can Be Automatically Synthesized

For convenience (unless we tell C++ otherwise), every class has a default constructor, even if you don't define one!

If you don't define a constructor, the compiler synthesizes a default constructor that initializes all member variables exactly as shown in the class definition. So if we didn't specify any initialization in the class definition,

• Member variables that hold primitive types (such as int , double, etc.) have indeterminate values.
• Member variables that hold objects of class type are initialized using their default constructors.

We can avoid this potentially dangerous issue for primitive types by specifying an initialization for member variables when we declare them in the class definition. For example, in our Cow class, we could have written

...

 private:
    // The number of spots and an age can't be negative...
    int numSpots_ = 4;
    int age_ = 0;
};
...

When You Don't Want a Default Constructor

If you don't want a default constructor, it isn't enough to just not define one, because in that case C++ will synthesize one automatically. Instead we must use some new syntax—= delete—to tell C++ that the class should not have a default constructor.

Here it is highlighted in our code

class Cow {
 public:
    // We can only have a Cow if we know
    // how many spots it has and how old it is
    Cow(int numSpots, int age);
    Cow() = delete;
...

In this context, specifying = delete tells the compiler to give an error if we write any code that tries to use this function.

In our running example, we can see that the default constructor for Cow has been effectively removed.

Because we removed the default constructor, the following code would no longer be allowed:

Cow buttercup; // Would cause a compile error!
Cow herd[5];   // Would cause a compile error!

Check-In Questions

(When logged in, completion status appears here.)