Why does C++ require a user-provided default constructor to default-construct a const object?

In C++, when an object is declared as const, it means that once initialized, its value cannot be changed. This presents a problem: if a class does not provide a default constructor, the compiler will synthesize one to initialize the object. However, if the class's member variables lack a default initialization method, this may result in the member variables being in an undefined state.

For const objects, this state is particularly dangerous because const objects, once created, cannot be modified. Therefore, all member variables must be initialized to a valid state from the beginning.

Consequently, when working with a const object, it is essential to ensure it is correctly initialized from the start. This typically requires providing a default constructor in your class to guarantee all member variables are initialized to a valid state.

For example, consider the following class:

cpp
class Example {
private:
    int value;
public:
    // No default constructor provided
    Example(int v) : value(v) {}
};

int main() {
    const Example ex; // This will fail to compile because Example has no default constructor
    return 0;
}

In this example, the Example class lacks a default constructor. Attempting to create a const Example object results in a compilation error because there is no suitable constructor to initialize the value member.

If we modify the class to add a default constructor that initializes value, this resolves the issue:

cpp
class Example {
private:
    int value;
public:
    Example() : value(0) {}  // Provide a default constructor
    Example(int v) : value(v) {}
};

int main() {
    const Example ex; // This will not result in a compilation error because we provided a default constructor
    return 0;
}

In this revised version, we add a default constructor initializing value to 0. This ensures const objects can be correctly initialized, thereby avoiding undefined states or compilation errors.