24

I noticed just now that the following code can be compiled with clang/gcc/clang++/g++, using c99, c11, c++11 standards.

int main(void) {
    int i = i;
}

and even with -Wall -Wextra, none of the compilers even reports warnings.

By modifying the code to int i = i + 1; and with -Wall, they may report:

why.c:2:13: warning: variable 'i' is uninitialized when used within its own initialization [-Wuninitialized]
    int i = i + 1;
        ~   ^
1 warning generated.

My questions:

  • Why is this even allowed by compilers?
  • What does the C/C++ standards say about this? Specifically, what's the behavior of this? UB or implementation dependent?
Improve this question
10
  • 3
    There is nothing "even" in -Wall -Wextra. That's about the bare minimum in warnings. See this answer of mine to an older question about -Wall... Commented Jan 15, 2019 at 14:09
  • 1
    -Wall is enough for me to get a warning for gcc Commented Jan 15, 2019 at 14:12
  • @Kevin no dice with gcc 7. gcc 8 seems to detect the issue Commented Jan 15, 2019 at 14:17
  • 2
    I improved the title and will mop up some old, bad duplicates, since the answers posted here so far are already better than those posted for the dupe questions. Commented Jan 15, 2019 at 15:48
  • 1
    The C++ part is a duplicate of stackoverflow.com/q/14935722/5376789 Commented Jan 15, 2019 at 16:07

3 Answers 3

Reset to default
19

Because i is uninitialized when use to initialize itself, it has an indeterminate value at that time. An indeterminate value can be either an unspecified value or a trap representation.

If your implementation supports padding bits in integer types and if the indeterminate value in question happens to be a trap representation, then using it results in undefined behavior.

If your implementation does not have padding in integers, then the value is simply unspecified and there is no undefined behavior.

EDIT:

To elaborate further, the behavior can still be undefined if i never has its address taken at some point. This is detailed in section 6.3.2.1p2 of the C11 standard:

If the lvalue designates an object of automatic storage duration that could have been declared with the register storage class (never had its address taken), and that object is uninitialized (not declared with an initializer and no assignment to it has been performed prior to use), the behavior is undefined.

So if you never take the address of i, then you have undefined behavior. Otherwise, the statements above apply.

Improve this answer
Sign up to request clarification or add additional context in comments.

12 Comments

It is perhaps relevant to include that the scope of identifier i begins at the end of its declarator, of which the initializer is not part. Thus i is in scope in its own initializer, even though it is not useful to initialize it with itself.
Also, there's a bit of a wiggly issue around C11 6.3.2.1/2, though I don't think that makes your analysis incorrect.
Can you elaborate this, better with reference to the standard?
@JohnBollinger This answer is essentially correct. The complete story including the 6.3.2.1 special case can be found here: (Why) is using an uninitialized variable undefined behavior?
@JohnBollinger Added further detail on whether i had its address taken.
|
13

This is a warning, it's not related to the standard.

Warnings are heuristic with "optimistic" approach. The warning is issued only when the compiler is sure that it's going to be a problem. In cases like this you have better luck with clang or newest versions of gcc as stated in comments (see another related question of mine: why am I not getting an "used uninitialized" warning from gcc in this trivial example?).

anyway, in the first case:

int i = i;

does nothing, since i==i already. It is possible that the assignment is completely optimized out as it's useless. With compilers which don't "see" self-initialization as a problem you can do this without a warning:

int i = i;
printf("%d\n",i);

Whereas this triggers a warning all right:

int i;
printf("%d\n",i);

Still, it's bad enough not to be warned about this, since from now on i is seen as initialized.

In the second case:

int i = i + 1;

A computation between an uninitialized value and 1 must be performed. Undefined behaviour happens there.

Improve this answer

8 Comments

Good answer; however, I am not sure about the "warnings issued, when the compiler is sure that there is going to be a problem". There are many warnings, where this isn't the case, this is highly dependent on the warning types enabled
The risk with int i = i + 1 is that UB is UB, period. Also, signed overflow. Also, much scratching of heads when another coder has to make sense of that code at some later point.
true! I forgot the sign. Edited out to make it simple
As @Ctx says. For example, I often find myself building third-party code that causes tons of warnings about use of possibly uninitialized variables. Control-flow analysis in those cases normally shows that the programmer included appropriate logic to ensure that the variable is assigned a value before its value is used. But the compiler is explicitly unsure whether there is a problem.
-Wparentheses would be another example.
|
5

I believe you are okay with getting the warning in case of

int i = i + 1;

as expected, however, you expect the warning to be displayed even in case of

int i = i;

also.

Why is this even allowed by compilers?

There is nothing inherently wrong with the statement. See the related discussions:

for more insight.

What does the C/C++ standards say about this? Specifically, what's the behavior of this? UB or implementation dependent?

This is undefined behavior, as the type int can have trap representation and you never have taken the address of the variable in discussion. So, technically, you'll face UB as soon as you try to use the (indeterminate) value stored in variable i.

You should turn on your compiler warnings. In gcc,

Improve this answer

2 Comments

no dice with -Winit-self either here, using gcc 7.3.1
you have a new version of gcc. Mine is older. When you say "probable source of undefined behavior (if the value of the variable is used later on)" it's the same as using it uninitialized.

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service and acknowledge you have read our privacy policy.

Start asking to get answers

Find the answer to your question by asking.

Ask question

Explore related questions

See similar questions with these tags.