C常量结构，包含堆栈上不同长度的数组

Question

I'm interested in creating a structure in C that (among other POD types) contains an array, and then creating global instances of this on the stack. The array length is known at compile time, but will be different for each instance of the struct. The values inside each instance of the struct will not change, and so should therefore be set to const.

Currently I have the following code:

#ifdef __cplusplus
    extern "C" {
#endif

#include "stdio.h"


typedef struct A
{
   int x;
   int y;
   int* z;
} A_t;

const A_t test[2]  = { {1,1, (int[3]){1,1,1}     },
                       {2,2, (int[5]){2,2,2,2,2} }
                     };

int main( void )
{
    printf( "test[0]: %d %d (%d, %d, %d)\n",
        test[0].x,
        test[0].y,
        test[0].z[0],
        test[0].z[1],
        test[0].z[2] );
    printf( "test[1]: %d %d (%d, %d, %d, %d, %d)\n",
        test[1].x,
        test[1].y,
        test[1].z[0],
        test[1].z[1],
        test[1].z[2],
        test[1].z[3],
        test[1].z[4] );
    printf( "\n\n" );


    return;
}

#ifdef __cplusplus
    }
#endif

This will be working on an embedded system where the heap is extremely limited, so I want to avoid malloc unless I absolutely have to. I also want to stick to C89 if possible, since VS2008 does not support C99 (I think).

This works fine in GCC (4.8.1 via MinGW), but doesn't compile in Visual Studio 2008. Does anyone have any suggestions as to how I can get it to work on both compilers?

For reference, here is the error message from VS2008:

c:\\temp\\test_variable_length_arrays\\bob.c(15) : error C2059: syntax error : '{'

c:\\temp\\test_variable_length_arrays\\bob.c(15) : error C2059: syntax error : '}'

c:\\temp\\test_variable_length_arrays\\bob.c(17) : error C2059: syntax error : '}

Thanks in advance for all comments.

Answer 1

You could allocate the inner structs globally, then assign into the struct at run time, eg

int x[] = {1,1,1};
int y[] = {3,3,3,3,3};

int main()
{
    A_t str = {2, 2, y};
}

I believe some compilers will also let you move the definition of str to global scope to make it fully static.

Answer 2

Visual Studio is choking on the following:

const A_t test[2]  = { {1,1, (int[3]){1,1,1}     },
                       {2,2, (int[5]){2,2,2,2,2} }

specifically, the compound literals (int[3]){1,1,1} and (int[5]){2,2,2,2,2} ; compound literals were introduced with C99, and will not be recognized by a C89 compiler such as Visual Studio.

Does this have to be compiled by Visual Studio? Can you build it with MinGW (Windows-native GNU compiler) or with gcc under cygwin, perhaps? If not, slugonamission's solution is probably going to be the path of least resistance.

Answer 3

See comments about (int[3]){1,2,3} syntax. But there is no guarantee that those arrays will persist in memory (they are temporaries). You could define them as global variables, and set the pointers to them:

static int az1[] = {1, 2, 3};
static int az2[] = {1, 2, 3, 4, 5};
const A_t test[2]  = { {1,1, az1 },
                       {2,2, az2 }
                     };