Answer.

Background

Before the C++11 standard, when needing to write multiple constructors with different parameters, it was necessary to duplicate initialization code in each of them, as there was no way to call another constructor within the class constructors.

Problem

The inability to reuse existing initialization logic in other constructors led to code duplication and errors when changing the initialization logic: updating one constructor, it was easy to forget about the others.

Solution

With the release of C++11, a mechanism for "delegating constructors" was introduced, allowing one constructor of a class to call another constructor of the same class through the initialization list syntax.

Code example:

class Widget {
public:
    Widget() : Widget(0, "default") {}
    Widget(int n) : Widget(n, "user") {}
    Widget(int n, std::string name) : size(n), label(name) {}
private:
    int size;
    std::string label;
};

Now all common logic is centralized in one "main" constructor, with all others delegating the call.

Key features:

Avoids duplication of initialization code
Increases reliability and maintainability
Delegation within the initialization list, not in the body of the constructor

Trick Questions.

Can a constructor delegate to another constructor through a function call inside its body?

No. Calling another constructor is only possible through the initialization list, not inside the body of the constructor. If a function is called from the body of the constructor, the object members would already be initialized.

What happens if a "ring" of delegation is created between constructors?

Circular delegation (e.g., A delegates to B, and B to A) results in a C++ compilation error: infinite recursion between constructors cannot occur.

Can a derived class's delegating constructor call a base class constructor?

No. Delegating constructors only work within one class. To call a base constructor, a separate syntax is used:

class Base {
public:
    Base(int) {}
};
class Derived : public Base {
public:
    Derived() : Base(42) {}
};

Common Mistakes and Anti-patterns

Violation of readability with excessive numbers of delegating constructors
Circular delegation — compilation error
Attempts to delegate a call to a base class constructor through a delegating constructor

Real-life Example

Negative Case

Three constructors, each explicitly initializing fields, logic is unsynchronized — changes made only in one constructor, the two others are incorrect.

Pros:

Easy to write

Cons:

High risk of logic divergence between constructors

Positive Case

One main constructor, others delegate to it, all initialization logic is centralized.