Constructors and member initialiser lists

Understanding Constructors and member initialiser lists

A constructor's contract is to hand back an object whose every member already holds a sensible value. The member initializer list, the comma-separated clause between the colon and the opening brace, is the only place where members are genuinely initialized; anything inside the braces already operates on members that exist. So Sensor(int id) : id_(id) {} builds id_ from id exactly once, while Sensor(int id) { id_ = id; } builds id_ with whatever default it has and then overwrites it.

The mental model is a checklist the compiler walks one member at a time, in the order the members are declared in the class. For each member it looks for a matching entry in your list; if there is none it falls back to the in-class default member initializer, then to the member's default constructor, and for a plain int or pointer with neither of those, to nothing at all, leaving an indeterminate value. Because the walk follows declaration order, rearranging the list changes nothing about execution; it only makes the code lie about what happens, which is why compilers offer -Wreorder.

For some members the list is not an optimisation but the only legal route. A const member and a reference member each get exactly one chance to acquire a value, and a member whose type has no default constructor has no empty state to sit in while the body runs, so assigning any of those later is a compile error. For everything else the list still wins on cost: a std::string or std::vector member assigned in the body is built empty, then discarded, sometimes with an allocation in each direction.

#include <iostream>
#include <string>
#include <utility>

class Tag {
public:
    Tag() : text_("<none>") { std::cout << "  Tag() default\n"; }

    explicit Tag(std::string t) : text_(std::move(t)) {
        std::cout << "  Tag(" << text_ << ")\n";
    }

    Tag& operator=(const Tag& other) {
        text_ = other.text_;
        std::cout << "  Tag= " << text_ << "\n";
        return *this;
    }

private:
    std::string text_;
};

class AssignInBody {
public:
    explicit AssignInBody(const std::string& t) {
        tag_ = Tag(t);   // tag_ was already default-built before we got here
    }
private:
    Tag tag_;
};

class InitInList {
public:
    explicit InitInList(const std::string& t) : tag_(t) {}
private:
    Tag tag_;
};

int main() {
    std::cout << "AssignInBody:\n";
    AssignInBody slow("slow");
    std::cout << "InitInList:\n";
    InitInList fast("fast");
}

Worked examples

#include <iostream>

struct Part {
    explicit Part(const char* name) { std::cout << "init " << name << "\n"; }
};

class Machine {
public:
    Machine() : third_("third"), first_("first"), second_("second") {
        std::cout << "body\n";
    }
private:
    Part first_;
    Part second_;
    Part third_;
};

int main() {
    Machine m;
}

#include <iostream>
#include <string>

class Port {
public:
    explicit Port(int number) : number_(number) {}
    int number() const { return number_; }
private:
    int number_;
};

class Connection {
public:
    Connection(std::string& log, int id, int portNumber)
        : id_(id), log_(log), port_(portNumber) {
        log_ += "opened id=" + std::to_string(id_)
              + " port=" + std::to_string(port_.number());
    }

    void describe() const {
        std::cout << "connection " << id_ << " on port " << port_.number() << "\n";
    }

private:
    const int id_;
    std::string& log_;
    Port port_;
};

int main() {
    std::string log;
    Connection c(log, 7, 8080);
    c.describe();
    std::cout << "log: " << log << "\n";
}

#include <iostream>

class Retry {
public:
    Retry() {}
    explicit Retry(int attempts) : attempts_(attempts) {}

    void print() const {
        std::cout << "attempts=" << attempts_ << " delayMs=" << delayMs_ << "\n";
    }

private:
    int attempts_ = 3;
    int delayMs_ = 100;
};

int main() {
    Retry fallback;
    Retry aggressive(5);
    fallback.print();
    aggressive.print();
}

Important notes

Common mistakes

Try it yourself