Self-referential variable initialization in C
I was reading the SDL Shader Language Quickstart, which (at the moment) mostly consists of explanations about how the language differs from C.
One difference listed caught my eye: variable initialization can't reference itself. To quote,
Why does C even allow this?
int x = x + 1;In C, x is in scope as soon as the parser sees int x, but this allows you to reference a variable that is definitely not initialized during its own initializer! Doing so is always a bug, so we just don't allow it.
I would consider myself fairly knowledgeable about the weird corners of C, but I had never come across this "feature"!
As stated, using the uninitialized value of the variable is going to be undefined behaviour in C. However, I did not immediately see why taking a pointer to the variable would be. So, as long as we only use the pointer of the value in its definition, that ought to be fine?
Normally, doing
type x = &x;
is going to fail because the types type and type* are not compatible.
However, in C (but not C++!) you can implicitly cast between void* and
any other pointer type, including void**.
This means we should be able to do
void *x = &x;
To test this, I made the following test program
#include <stdio.h>
int main(void) {
void *x = &x;
// We need an explicit cast for &x here, since printf is a
// varargs function.
printf("x = %p, &x = %p\n", x, (void*)&x);
}
And with GCC 14.2.0, this does indeed work, with zero warnings with the
flags -std=c23 -Wall -Wextra -pedantic!