I'd like to initialize a char array with a conditional string constant
where the condition can be computed at compile time. Although this
works for int and char pointer, it does not work with char array.
Both, GCC and Clang give error messages for the 3. initialization in
the following code:

$ cat foo.c
#define COND() (1 < 2)
int i = COND() ? 42 : 4711;
char *p = COND() ? "42" : "4711";
char s[8] = COND() ? "42" : "4711";
$ gcc -S foo.c
foo.c:1:16: error: invalid initializer
1 | #define COND() (1 < 2)
| ^
foo.c:4:13: note: in expansion of macro ���COND���
4 | char s[8] = COND() ? "42" : "4711";
| ^~~~
$ clang -S foo.c
foo.c:4:6: error: array initializer must be an initializer list or string literal
char s[8] = COND() ? "42" : "4711";
^
1 error generated.

Why can't a char array have an expression as initializer?

Steve

Steve Keller <keller.steve@gmx.de> writes:

> I'd like to initialize a char array with a conditional string constant
> where the condition can be computed at compile time. Although this
> works for int and char pointer, it does not work with char array.
> Both, GCC and Clang give error messages for the 3. initialization in
> the following code:
>
> $ cat foo.c
> #define COND() (1 < 2)
> int i = COND() ? 42 : 4711;
> char *p = COND() ? "42" : "4711";
> char s[8] = COND() ? "42" : "4711";
> $ gcc -S foo.c
> foo.c:1:16: error: invalid initializer
> 1 | #define COND() (1 < 2)
> | ^
> foo.c:4:13: note: in expansion of macro ‘COND’
> 4 | char s[8] = COND() ? "42" : "4711";
> | ^~~~
> $ clang -S foo.c
> foo.c:4:6: error: array initializer must be an initializer list or string literal
> char s[8] = COND() ? "42" : "4711";
> ^
> 1 error generated.
>
> Why can't a char array have an expression as initializer?

It depends on what sort of answer you want! "The language does not
permit it" is one possible answer, and the second error message gives a
slightly more detailed version of the same: C's initialisers are rather
limited.

But there are other factors in play here. Even if the syntax were
permitted, the string literal would not survive the conditional
expression. Writing

char a[] = "abc";

is a special case where the array "abc" is /not/ converted to a pointer
to its first element. An expression like c ? "a" : "b" /never/ has an
array value; its always of type char *.

Bottom line... you just have to accept that you can't do that in C.

PS: Your quoted error message had a bad case of mojibake. I've tried to
fix it.

--
Ben.

On Sunday, 21 August 2022 at 05:30:24 UTC+1, Steve Keller wrote:

> char s[8] = COND() ? "42" : "4711";

> Why can't a char array have an expression as initializer?

It needs to have a char array as an initialiser. C doesn't allow array values in expressions.

That it allows this at all:

char s[8] = "ABCDEFG";

is enough of a quirk. (The alternative would be laboriously typing {'A', 'B', 'C', ..., 'G', 0}.)

Maybe the language could have gone further and extended the quirk into the ?: term, but perhaps it was felt it had already strayed enough outside the language's type rules.

You can however do this:

#if COND()
char s[8] = "42";
#else
char s[8] ="4711";
#endif

bart c <bart4858@gmail.com> writes:

> On Sunday, 21 August 2022 at 05:30:24 UTC+1, Steve Keller wrote:
>
>> char s[8] = COND() ? "42" : "4711";
>
>> Why can't a char array have an expression as initializer?
>
> It needs to have a char array as an initialiser.

Not quite -- it must be a string literal. Any old char array won't do.

> C doesn't allow array values in expressions.

In both of

sizeof "a"
&"abc"

there is an array value in an expression. In fact, ordinary expressions
like

"abc"[0]
f("abc")

contain array values -- just ones that convert immediately to pointers.

--
Ben.

On 8/20/2022 9:30 PM, Steve Keller wrote:
>
> Why can't a char array have an expression as initializer?
>

Because the language is defined that way.

Naked arrays in C are generally non-copyable. So, you are not allowed to
initialize one array with another array, aside from one exception: you
are allowed to initialize a character array with a string literal.

This is a very narrow, very focused and very fragile exception from the
general rule. The moment you change anything, the exception no longer
applies. In your case the RHS of the initialization is "some
expression", not a string literal. So, the exception no longer applies
and we are back to the general rule: arrays are non-copyable in C.

--
Best regards,
Andrey

bart c <bart4858@gmail.com> writes:

> On Sunday, 21 August 2022 at 05:30:24 UTC+1, Steve Keller wrote:
>
> > char s[8] = COND() ? "42" : "4711";
>
> > Why can't a char array have an expression as initializer?
>
> It needs to have a char array as an initialiser. C doesn't allow
> array values in expressions.

OK, I see. A pity.

> You can however do this:
>
> #if COND()
> char s[8] = "42";
> #else
> char s[8] ="4711";
> #endif

I'd like to, and have done similar things often before. In this case,
however, my condition can't be evaluated by the preprocessor. I'd
like to check whether char is signed or unsigned. I'll probably
change s[] to *s although I'd prefer s[] in this particular case.

Steve

On Mon, 22 Aug 2022 20:17:34 +0200, Steve Keller wrote:

> bart c <bart4858@gmail.com> writes:
>
>> On Sunday, 21 August 2022 at 05:30:24 UTC+1, Steve Keller wrote:
>>
>> > char s[8] = COND() ? "42" : "4711";
>>
>> > Why can't a char array have an expression as initializer?
>>
>> It needs to have a char array as an initialiser. C doesn't allow array
>> values in expressions.
>
> OK, I see. A pity.
>
>> You can however do this:
>>
>> #if COND()
>> char s[8] = "42";
>> #else
>> char s[8] ="4711";
>> #endif
>
> I'd like to, and have done similar things often before. In this case,
> however, my condition can't be evaluated by the preprocessor. I'd like
> to check whether char is signed or unsigned.

Wouldn't
#include <limits.h>
#if (CHAR_MIN < 0)
char s[8] = "signed";
#else
char s[8] = "unsigned";
#endif
work for you?

> I'll probably change s[]
> to *s although I'd prefer s[] in this particular case.
>
> Steve

--
Lew Pitcher
"In Skills, We Trust"

On 22/08/2022 20:17, Steve Keller wrote:
> bart c <bart4858@gmail.com> writes:
>
>> On Sunday, 21 August 2022 at 05:30:24 UTC+1, Steve Keller wrote:
>>
>>> char s[8] = COND() ? "42" : "4711";
>>
>>> Why can't a char array have an expression as initializer?
>>
>> It needs to have a char array as an initialiser. C doesn't allow
>> array values in expressions.
>
> OK, I see. A pity.
>
>> You can however do this:
>>
>> #if COND()
>> char s[8] = "42";
>> #else
>> char s[8] ="4711";
>> #endif
>
> I'd like to, and have done similar things often before. In this case,
> however, my condition can't be evaluated by the preprocessor. I'd
> like to check whether char is signed or unsigned. I'll probably
> change s[] to *s although I'd prefer s[] in this particular case.
>
> Steve

Out of curiosity, why do you need to check if char is signed or
unsigned? Why not use "signed char" and "unsigned char" explicitly when
it is relevant?

Lew Pitcher <lew.pitcher@digitalfreehold.ca> writes:

> Wouldn't
> #include <limits.h>
> #if (CHAR_MIN < 0)
> char s[8] = "signed";
> #else
> char s[8] = "unsigned";
> #endif
> work for you?

Ouch, that was seemingly too simple :-(( Yes, of course will that work.
I just didn't think of limits.h and instead tried (char)-1 >= 0.
Thanks.

Steve

David Brown <david.brown@hesbynett.no> writes:

> Out of curiosity, why do you need to check if char is signed or
> unsigned? Why not use "signed char" and "unsigned char" explicitly
> when it is relevant?

It's a very simple tool, that prints out sizes of some types, offsets
of some struct members, and for char, whether it's sigend or unsigned.
I sometimes only cross-compile it looking at the asm output without
running it. Therefore, having the strings directly in an array s[]
would be a bit easier than having to follow the pointer *s.

Steve

On 23/08/2022 10:35, Steve Keller wrote:
> David Brown <david.brown@hesbynett.no> writes:
>
>> Out of curiosity, why do you need to check if char is signed or
>> unsigned? Why not use "signed char" and "unsigned char" explicitly
>> when it is relevant?
>
> It's a very simple tool, that prints out sizes of some types, offsets
> of some struct members, and for char, whether it's sigend or unsigned.
> I sometimes only cross-compile it looking at the asm output without
> running it. Therefore, having the strings directly in an array s[]
> would be a bit easier than having to follow the pointer *s.
>
> Steve

Why not have a series of declarations like :

const int sizeShort = sizeof(short);
const int sizeInt = sizeof(int);

const int charMinus1 = (char) -1;

and compile that, or paste it into <https://godbolt.org> (which has
compiler options for a fair number of targets) ?

You can test it with gcc (for lots of targets) using the "-fsigned-char"
or "-funsigned-char" options to see the difference.

I find the best idea for writing code when you want control of the sizes
of types (and when do you /not/ want that?) is to use the types in
<stdint.h>. It's very rare that I need to care about the size of
"short" or "long", as I use uint16_t, int32_t, uintptr_t, as required by
the needs of the code. And of course uint8_t and int8_t instead of
worrying about the sign of "char". If that's not to your liking, then
<limits.h> can give you plenty of compile-time help.

Of course, knowing the sizes on a particular implementation can help
understanding code written by someone else.