1

My issue is fairly straightforward. I am trying to initialize the struct in my main function but I get the following error:

$ gcc main2.c -o main2
main2.c: In function ‘main’:
main2.c:39:28: error: initializer element is not constant
             .smth.array = (mylib_B_t)
                            ^
main2.c:39:28: note: (near initialization for ‘C.smth.array’)

I tried multiple different ways, yet nothing seems to work. Could someone tell me what I am doing incorrectly? Below is the code in question:

#include <stdio.h>

typedef struct mylib_A_t mylib_A_t;
typedef struct mylib_B_t mylib_B_t;
typedef struct mylib_C_t mylib_C_t;

typedef enum
{
    TYPE_A = 0,
    TYPE_B  = -1
} lib_type_t;

struct mylib_A_t
{
    lib_type_t type;
    int d;
};

struct mylib_B_t
{
     int c;
     const mylib_A_t *size;
 };

struct mylib_C_t
{
    union
    {
        int b;
        mylib_B_t array;
     } smth;
};

int main (int argc, char * argv[])
{
    static const mylib_C_t C=
    {

        .smth.array = (mylib_B_t)
        {
            .c = 66,
            .size = &(mylib_A_t)
                   {
                       .type = TYPE_A,
                       .d = 0
                   }
        }
    };
    return 0;
}
Improve this question
3
  • What is field in the error message? It is not in the source code. Commented Jan 4, 2018 at 21:14
  • I assume you confused field with smth.array in your MCVE.The address of a memory object is not considered a constant expression. For static memory objects you need constant initializers. The problem is this line then: .size = &(mylib_A_t). Make C non static or initialize .size during runtime. Also size is a very strange name for a pointer.... Commented Jan 4, 2018 at 21:17
  • The code is far from "straightforward" especially when you name a pointer to a struct as const mylib_A_t *size; Commented Jan 4, 2018 at 21:20

1 Answer 1

Reset to default
4

Initializers for objects with static storage duration must consist of constant expressions. Your code runs afoul of that in two ways, both related to use of compound literals.

This is a compound literal of type mylib_A_t:

(mylib_A_t)
{
    .type = TYPE_A,
    .d = 0
}

. It represents an object of type mylib_A_t, and even though its initial value is defined in terms of constants, it is neither a "constant" nor a "constant expression" as the standard uses that term.

You also seem not to appreciate that although they have similar syntax, initialization expressions, including nested initializers, are not assignment statements, and they do not follow the same rules. In particular, the standard specifies that

More latitude is permitted for constant expressions in initializers [as opposed to elsewhere]. Such a constant expression shall be, or evaluate to, one of the following:

  • an arithmetic constant expression,
  • a null pointer constant,
  • an address constant, or
  • an address constant for a complete object type plus or minus an integer constant expression.

(C2011, 6.6/7)

You can write your initialization like so:

int main (int argc, char *argv[]) {
    // You cannot avoid a declaration of such a static-duration object if
    // you want to use a pointer to such an object in the initializer of C:
    static const mylib_A_t A = {
        .type = TYPE_A,
        .d = 0
    };

    static const mylib_C_t C = {
        // The initializer for .smth.array must be (just) a brace-enclosed
        // initializer list, NOT a compound literal
        .smth.array = {
            .c = 66,
            // &A is an address constant; the pointer expression in your
            // original code is not
            .size = &A
        }
    };
    return 0;
}

There, all the initializers are written in terms of the kinds of constant expressions that are permitted in that context.

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

2 Comments

Thx for your answer, a few questions however. 1)By " 'they' have similar syntax.." are you referring to constant expressions and initialization expressions? 2) I tried reproducing the code above with a constant pointer but still didn't work. An address is a constant value, or am I crazy? Yet neither did the code above work neither this simplified snippet: pastebin.com/8ZqFBQnn 3) why is it such a big deal to use compount litterall where you wrote "initializer list, NOT a compound literal". A compound is simply a cast afaik.
@traducerad, 1) "they" = assignment statements and initializers. 2) The code I presented works for me with gcc -std=c11. Your pastebin is flawed because the address of an automatic variable is not a constant, unlike the address of a variable with static duration such as in the above. 3) That's the point: compound literals are not casts and do not comprise casts, and they are not allowed in initializers. Again, an initializer is not an assignment. They have similar but not identical syntax, and different rules.

Your Answer

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