The parsing details can be complicated while the end result can be simple. Consider the actual C++ example that would be taught & used in practice:
struct A {
int i = 0;
}
int main() {
A a;
std::cout << a.i << std::endl;
}
Hey, look, done. And you only had to teach a single thing - default initialization. Which has an obvious & simple syntax. The int i is always initialized to 0, as intended, and it's in a single spot at the point of declaration.
Now try doing that in C. Oh, wait, you can't. The closest you can get is this mess:
struct A {
int i;
} const default_A = {0};
int main() {
struct A a5 = default_A;
printf("%d\n", a5.i);
}
Which requires you to know that you can declare a type & an instance of that type in a single statement, why that const is where it is and why that's important here, how braced initialization rules work, that you need to always remember to manually initialize to your default_A, and that %d means 'int'. And the compiler won't help you with any of this except for the %d part if you get it wrong.
> Which requires you to know that you can declare a type & an instance of that type in a single statement
struct A {
int i;
};
const struct A default_A = { 0 };
Why didn't you try the obvious simple thing first?
The whole undertaking is pointless in any case. Why would you need default values (i.e. templates for constructors) baked in? The only reasonable default value, sometimes, is all-zeroes (or all-ones...).
Now, constant data (i.e. things that contain more useful information than just "it's the default because a real value is missing" -- and that aren't copied around pointlessly) is another case, and C's plain old value initializer syntax (as demonstrated above) serves it perfectly well.
> The only reasonable default value, sometimes, is all-zeroes (or all-ones...).
That's very false. Consider a basic string container with a small-size optimization. The default value for capacity is neither 0 nor 1, but the size of the inline array.
Similarly it could be an enum value, and the default for a given class isn't whatever the 0 value happened to line up with because that's arbitrary anyway. An example being a basic type id of a fixed number of types.
Now try doing that in C. Oh, wait, you can't. The closest you can get is this mess:
Which requires you to know that you can declare a type & an instance of that type in a single statement, why that const is where it is and why that's important here, how braced initialization rules work, that you need to always remember to manually initialize to your default_A, and that %d means 'int'. And the compiler won't help you with any of this except for the %d part if you get it wrong.