For example, your example could legally be rewritten to:
int x;
f();
x = 1;
if (g()) { h(x); }
f();
if (g()) { h(1); }
EDIT: Note the further optimization that looms: if f() can be proven pure (no side effects), then it can be removed. This makes little sense for a function with no arguments (in which case it would just be a constant). If, however, f(y, ...) is some expensive but pure function, it can just be removed completely.
It could apply if f computes a value based on global state but doesn't change anything, which is slightly weaker than "pure".
So changing that behavior means that the compiler now rejects 40 years worth of correctly working legacy code (and some buggy code, as well). Newer languages (e.g. Java, C#) that don't have to support existing code can afford to do what you want and reject programs where a simple heuristic isn't enough to tell whether a variable is initialized or not.
int x;
h(x);
On top of that, the C compilers I know more or less have that, as they give warnings for basically cases where Java (with its stricter rules) would refuse to compile equivalent code, and have a flag that turns warnings into errors.
Often there is no sane default value.
g() might have side-effects, and those side-effects have to happen regardless of whether or not f() returned true.
if (f()) {
int x = 1;
if (g()) {
h(x);
}
} else {
g();
}
int g_flag = g();
if (f()) {
int x = 1;
if (g_flag) {
h(x);
}
|
int f_flag = f(); // force f() to run for ${reasons}
int g_flag = g(); // force g() to run for ${reasons}
if (f_flag && g_flag) {
h(1);
}
You should never rely on uinitialized values not just because of the problems relating to undefined behavior, but also because you're adding in assumptions about the runtime state. The code depended on the return value of f() but did not fully express that dependency in the code.
You cannot implement that efficiently without rejecting valid programs. Consider code like this:
For sufficiently complex functions f and g, there's no reasonable way to decide at compile time whether x will be set whenever g() returns true. For example, f() might always return false because Fermat's last theorem is true.And that 'reasonable' likely isn't a necessary part of that statement.