I know that const != constant, but I haven't been able to figure out why static int *foo = {(int []){42}}; in the below program prints the error initializer element is not a compile-time constant with both gcc and clang. I've tried a bunch of stuff on godbolt, but haven't been able to figure out the answer.
#Why does this error with "initializer element is not a compile-time constant"?
dusty temple
inland bearBOT
dusty temple
;compile -Wall -Wextra -Werror -Wpedantic -g -fsanitize=address,undefined
int main(void) {
static int *foo = {(int []){42}};
(void)foo;
}
stone forgeBOT
bold frost
try constexpr on c2x
dusty temple
try constexpr on c2x
;compile -Wall -Wextra -Werror -Wpedantic -g -fsanitize=address,undefined -std=c2x
int main(void) {
static constexpr int *foo = {(int []){42}};
(void)foo;
}
mild sierra
static variables can only use initialisers that are constant expressions.
A compound literal like that unfortunately does not fall into that category.
bold frost
can you not constexpr them ?
dusty temple
Oh well, not the `constexpr` they did there at least.
Wdym by "they did there"? Is there like an alternative?
bold frost
yea doesnt seem to work
mild sierra
Wdym by "they did there"? Is there like an alternative?
It is this:
const int *f = (constexpr int[]){42};
Only available from 2023 though.
dusty temple
It is this:
```c
const int *f = (constexpr int[]){42};
```
Is there a way to make my original line compile without C23's constexpr, while keeping it a single line?
dusty temple
In practice instead of an int it was an array of char *
mild sierra
Then you can use a string literal.
But a normal array declaration seems to work as well.
const char *const presets[] = {"LOW", "MID", "HIGH"}; works.
dusty temple
`const char *const presets[] = {"LOW", "MID", "HIGH"};` works.
Right, I forgot to mention that the idea is that I need it as a field in a static struct:
;compile -Wall -Wextra -Werror -Wpedantic -g -fsanitize=address,undefined -std=c2x
struct s {
char **arr;
};
int main(void) {
static struct s foo = {.arr=(char *[]){"a", "b"}};
(void)foo;
}
Where consting it doesn't seem to fix it:
;compile -Wall -Wextra -Werror -Wpedantic -g -fsanitize=address,undefined -std=c2x
struct s {
char const *const *const arr;
};
int main(void) {
static struct s const foo = {.arr=(char const *const []){"a", "b"}};
(void)foo;
}
Sorry for not giving this info before, I didn't realize that my minimal example was too minimalized
mild sierra
You can declare the array as another static variable.
tropic obsidian
;compile -Wall -Wextra -Werror -Wpedantic -g -fsanitize=address,undefined
```c
i...
this is because the compound literal is in block scope
;compile -Wall -Wextra -Werror -Wpedantic -g -fsanitize=address,undefined
static int *foo = {(int []){42}};
int main(void) {
(void)foo;
}
this works fine
;compile -Wall -Wextra -Werror -Wpedantic -g -fsanitize=address,undefined -std=c2x
int main(void) {
static int *foo = {(static int []){42}};
(void)foo;
}
also in C2X this is valid
tropic obsidian
A compound literal like that unfortunately does not fall into that category.
you can take the address of a compound literal just fine, the issue is really just because of the lifetime of the compound literal
mild sierra
Uhm... that was not what I was talking about.
tropic obsidian
Uhm... that was not what I was talking about.
then what were you talking about
mild sierra
That it's not a constant expression.
tropic obsidian
it is a valid constant expression, you just can't use the value of it
tropic obsidian
;compile -Wall -Wextra -Werror -Wpedantic -g -fsanitize=address,undefined
```c
s...
see here
dusty temple
this is because the compound literal is in block scope
I presume the scope matters, even when the statement is marked as static, because the temporary inner compound literal isn't going to be static in block scope, but is in global scope? Very strange
And any clue why it's valid in c2x? They just made the rules more lenient?
tropic obsidian
I presume the scope matters, even when the statement is marked as `static`, beca...
yes
tropic obsidian
And any clue why it's valid in c2x? They just made the rules more lenient?
C2X allows for storage class specifiers in compound literals