A constructor turns raw storage into an object that keeps its promises. It runs exactly once per object, before any other member function can, and it is the only code that ever sees the members before they hold meaningful values. This lesson covers the constructors you write and the ones the compiler writes for you, the member-initialiser list and why it beats assignment in the body, the rule that members are initialised in declaration order whatever the list says, delegating constructors, explicit, and = default / = delete.

Declaring constructors

#include <iostream>
#include <string>

class Account {
    std::string owner_;
    long long balance_ = 0;         // default member initialiser
public:
    Account() = default;                           // (1) default constructor
    Account(std::string owner, long long opening)  // (2) parameterised
        : owner_(std::move(owner)), balance_(opening) {}
    long long balance() const { return balance_; }
};

int main() {
    Account a;                       // (1)
    Account b{"ada", 500};           // (2)
    Account c("bob", 20);            // (2), parentheses also work
    std::cout << b.balance() << '\n';
    return 0;
}

A constructor has the class's name, no return type — not even void — and any number of parameters; constructors overload like functions (Module 4, lesson 3). A constructor with no parameters (or with defaults for all of them) is the default constructor, used by Account a;, by std::vector<Account> v(10), and by every array of Account. Braces and parentheses both call a constructor; braces reject narrowing and cannot be mistaken for a function declaration, which is why this track prefers them for objects.

What the compiler writes for you

If a class declares no constructor at all, the compiler generates a public default constructor that default-initialises each member: class-type members run their own default constructors, members with a default member initialiser take it, and fundamental members with neither are left indeterminate. Declare any constructor and the implicit default constructor is not generated — Account a; becomes a compile error the moment you add Account(std::string, long long). That is exactly the situation the = default line above handles: it asks for the compiler-generated version explicitly. The mirror image is = delete, which declares a constructor in order to forbid it:

class Session {
public:
    Session(int id) : id_(id) {}
    Session() = delete;         // "no Session without an id" — the error names the deleted function
private:
    int id_;
};

Copy and move constructors are generated by the same mechanism and are the subject of Module 9; for now, know that the rules for those are separate from the rule for the default constructor.

The member-initialiser list

The part between the : and the body is the member-initialiser list. It is not decoration — it is where members are constructed, and it is the difference between initialising and assigning:

class Widget {
    std::string name_;
    const int id_;
    std::vector<int>& log_;
public:
    Widget(std::string name, int id, std::vector<int>& log)
        : name_(std::move(name)), id_(id), log_(log) {}   // initialised

    // Widget(std::string name, int id, std::vector<int>& log) {
    //     name_ = name;   // name_ was default-constructed first, then assigned: two operations
    //     id_ = id;       // error: assignment to a const member
    //     log_ = log;     // error: a reference must be bound at initialisation
    // }
};

By the time the body's opening brace runs, every member already exists. A member you did not list was default-initialised — an empty std::string, a vector with nothing in it, an indeterminate int — and assigning to it in the body is a second operation on top of the first. For std::string that is a wasted construction; for a const member, a reference member, or a member whose type has no default constructor, it is a compile error, because the body is too late. The rule: initialise every member in the list; the body is for work that needs all the members to exist, such as validation or a log line. A default member initialiser (balance_ = 0 above) is the fallback the list does not override, which lets a class with several constructors state each default once.

Initialisation order is declaration order

class Buffer {
    std::vector<int> data_;
    std::size_t size_;
public:
    Buffer(std::size_t n) : size_(n), data_(size_) {}   // BUG: data_ is built first, from an indeterminate size_
};

Members are initialised in the order they are declared in the class, never in the order they appear in the list. Here data_ is declared first, so data_(size_) runs before size_(n), reading size_ before it holds anything — undefined behaviour that happens to work in a debug build and produces a random-length vector under -O2. GCC and Clang warn with -Wreorder (part of -Wall) whenever the list disagrees with the declaration order; treat it as an error. Write the list in declaration order, and never let one member's initialiser read a member declared after it — read the parameter (data_(n)) instead. Destruction runs in the reverse of construction: members are destroyed after the destructor body, last-declared first (Module 7, lesson 3).

Delegating constructors

class Money {
    long long cents_;
public:
    explicit Money(long long cents) : cents_(cents) {}
    Money(long long units, int hundredths) : Money(units * 100 + hundredths) {}   // delegates
    Money() : Money(0) {}
};

A constructor whose initialiser list names another constructor of the same class delegates the whole job to it; the delegating constructor's own body, if any, runs after the target finishes. The target must be the only entry in the list — you cannot delegate and also initialise a member. Delegation keeps validation in one place: whatever Money(long long) checks, every other constructor gets for free. Before C++11 the same effect needed a private init() member called from each constructor, which could not initialise const members and left objects half-built if it failed.

explicit

void charge(Money amount);

Money m = 5;      // without explicit: 5 converts to Money(5) — five cents, or five units?
charge(250);      // without explicit: an int silently becomes a Money

A constructor callable with one argument is a converting constructor: the compiler may use it to convert a value of that argument type into your class, implicitly, anywhere a value of your class is expected. That is what makes std::string s = "text"; work — and it is wrong for almost any class of your own, where a bare 250 has no obvious meaning. explicit switches the conversion off: Money m{250}; and Money(250) still work, Money m = 250; and charge(250) do not compile. The rule the standard library follows and this track adopts: every constructor that can be called with one argument is explicit unless the conversion is the whole point. explicit also applies to multi-argument constructors, where it blocks the brace form charge({2, 50}).

Validation belongs in the constructor

#include <stdexcept>

class Percentage {
    int value_;
public:
    explicit Percentage(int v) : value_(v) {
        if (v < 0 || v > 100) throw std::invalid_argument("percentage out of range");
    }
};

If an object can be built with inconsistent members, every member function has to defend against it forever. Checking in the constructor means a Percentage that exists is valid. When the arguments cannot make a valid object, the constructor's only escape is to throw — there is no return value to signal failure with — and a constructor that throws produces no object at all. Module 15 covers exceptions in full; lesson 6 of this module puts validation to work in a complete design.

Pitfalls

Key takeaways

• Constructors have the class's name, no return type, and overload; declaring any constructor removes the implicit default one — = default restores it, = delete forbids it.
• Initialise members in the member-initialiser list; the body runs after every member exists.
• Members are initialised in declaration order regardless of the list; never read a later member.
• A constructor can delegate to another; the target is then the whole list.
• Mark single-argument constructors explicit unless an implicit conversion is intended.
• Validate in the constructor, so that an object that exists is valid.