Just performed a technical interview and during one of the discussions the candidate end up with the following code in codepad: struct S { int x = x; };

A bit to my surprise it compiled successfully with the codepad built-in GCC 12.

Then I was wondering what does that even mean.

It turns out that in C++20 this is a syntactically correct designated initializer for a non-union aggregate. And no one explicitly forbids it from being self-referential!
So basically that's attempt to assign the x value to the same x. Before it was initialized. And yes, that's possible, and yes, that's UB.

The more I see C++ code the more I grow an opinion "You can type any random string into modern C++ compiler and it would compile successfully. And it will contain at least one UB."

#dev #cpp

@Revertron yep. Working on it!

@rayslava

@Revertron @rayslava gcc will output a warning;
main.c:6:26: warning: format ‘%d’ expects a matching ‘int’ argument [-Wformat=]
6 | printf("Number: %d\n"), number;
| ~^
| |
| int

What that line does is calls printf without any argument (which won't cause a crash, as whatever garbage is in memory or in the register will print out) and then writes the value of number to nowhere (gcc will optimize that null operation out if optimizations are enabled).

The x,x; operator is a way to execute 2 or more operations in one line, for example;
printf("Number: %d\n", number), ++number, printf("Number incremented: %d\n", number);

Although you would really write; printf("Number: %d\n", number), printf("Number incremented: %d\n", ++number);

Or actually; printf("Number: %d\nNumber incremented: %d\n", number++, number);

Watch out: unlike the sequencing implied by the comma operator, there's no sequence point between the arguments to a function, and they may be evaluated in any order, or even have their evaluation interleaved.

CC: @rayslava @Revertron

Watch out: unlike the sequencing implied by the comma operator, there's no sequence point between the arguments to a function, and they may be evaluated in any order, or even have their evaluation interleaved.

CC: @rayslava @Revertron

@lxo @rayslava @Revertron Thanks, you probably saved me some time there, as I hadn't yet decided to use it in a non-trivial case (so far I've used it do to `++i, ++j;`);

trying to get too clever with side effects and sequence points of little visibility is probably bad practice anyway, except when writing code for obfuscated programming contests

the fact that the comma operator sequences the right operand after the left operand, while the argument separator with the same spelling ',' doesn't, is a somewhat common source of undesirable surprises

CC: @rayslava @Revertron