如何初始化作为 C 中结构元素的数组？

Question

I have a struct like this in a header file.

typedef struct test
{
   int a;
   int b[10];
   int c[5][6];
}testStruct;

I have initialized the elements individually in another function like below.

void foo()
{
   testStruct t[2];
   t[0].a = 10;
   for(int i = 0; i < 10; i++)
   {
      t[0].b[i] = i;
   }
   for(int i = 0; i <5; i++)
   {
       for(int j =0; j < 6; j++)
       {
          t[0].c[i][j] = j;
       }
    }

This kind of initialization works. But I am using this in an embedded C project. And I'm running into RAM issues because the struct is taking up huge size. After searching for solutions, I found that I can place variables in ROM by making them constant. But I am not able to make this struct as constant. One of the ways I found was to initialize the structure as constant like below.

const testStruct t2 = { 0, {1,2 ..}, {3.4...} }

The problem is, I am not sure how to intialize the array elements. Because array size in my project runs upto 100+ elements. I want to know if there is way I can initialize this structure and also make it a constant so that it gets stored in ROM.

Any help is appreciated:)

Answer 1

You can't simply do loops while initializing constants in C. You should find another way to solve this problem. I can suggest two solutions:

1. Use online array generator, like this one: https://yupana-engineering.com/online-c-array-generator , or
2. Write your own generator using BASH, Python or another scripting language which can be integrated in your build process on pre-build stage.

Answer 2

This is normally done by "hard-coding" everything. In case the initializers are complex, the C source for the initializers could be generated by external scripts.

In some cases, you may be able to solve it with the pre-processor as well, but it's not an ideal tool for the task, since it makes the code hard to read. And also, in order to come up such various forms of project-specific "clever" macros, you need quite extensive C knowledge of obscure language features in combination with a "think outside the box" mindset.

In your case for example, where you need numeric sequences, you could cook up some macros such as these:

#define SEQ1 0,
#define SEQ2 SEQ1 1,
#define SEQ3 SEQ2 2,
#define SEQ4 SEQ3 3,
#define SEQ5 SEQ4 4,
#define SEQ6 SEQ5 5,
#define SEQ7 SEQ6 6,
#define SEQ8 SEQ7 7,
#define SEQ9 SEQ8 8,
#define SEQ10 SEQ9 9,

#define SEQUENCE(n) {SEQ##n}

After which you can initialize the struct like this:

const testStruct t[2] =
{
  [0] = 
  {
    .a = 10,
    .b = SEQUENCE(10),
    .c = { SEQUENCE(6),SEQUENCE(6),SEQUENCE(6),SEQUENCE(6),SEQUENCE(6) },
  },
};

---

Another such a trick would be to create a union with a macro like

#define SEQUENCE_TYPE(n) typedef union { int arr_max[10]; int arr[n]; } sequence_trick;

And then

static const sequence_trick trick = { .arr_max=(int[]){0,1,2,3,4,5,6,7,8,9} };

trick.arr // here you have a const array of length n, compile-time initialized to values 0,1,..., n

Answer 3

You already did this the normal/typical/easy way?

typedef struct test
{
   int a;
   int b[10];
   int c[5][6];
}testStruct;

const testStruct t2 = { 0, {1,2 ..}, {3.4...} }

Not sure I understand the question as you already have and have implemented the answer.

#define SECOND_PASS
#include <stdio.h>
typedef struct test
{
   int a;
   int b[10];
   int c[5][6];
}testStruct;
testStruct t[2];
#ifdef SECOND_PASS
const testStruct test[2]=
{
{/*0*/
/*a*/10,
{/*b*/0,1,2,3,4,5,6,7,8,9,},
{/*c*/
{/*0*/0,1,2,3,4,5,},
{/*1*/1,2,3,4,5,6,},
{/*2*/2,3,4,5,6,7,},
{/*3*/3,4,5,6,7,8,},
{/*4*/4,5,6,7,8,9,},
}/*c*/,
}/*0*/,
{/*1*/
/*a*/11,
{/*b*/1,2,3,4,5,6,7,8,9,10,},
{/*c*/
{/*0*/1,2,3,4,5,6,},
{/*1*/2,3,4,5,6,7,},
{/*2*/3,4,5,6,7,8,},
{/*3*/4,5,6,7,8,9,},
{/*4*/5,6,7,8,9,10,},
}/*c*/,
}/*1*/,
};
#endif

int main ( void )
{
    unsigned int ra;
    for(ra=0;ra<2;ra++)
    {
        t[ra].a = 10+ra;
        for(int i = 0; i < 10; i++)
        {
            t[ra].b[i] = i+ra;
        }
        for(int i = 0; i <5; i++)
        {
            for(int j =0; j < 6; j++)
            {
                t[ra].c[i][j] = j+i+ra;
            }
        }
    }

    printf("{\n");
    for(ra=0;ra<2;ra++)
    {
        printf("{/*%d*/\n",ra);

        printf("/*a*/%d,\n",t[ra].a);

        printf("{/*b*/");
        for(int i = 0; i < 10; i++)
        {
            printf("%d,",t[ra].b[i]);
        }
        printf("},\n");

        printf("{/*c*/\n");
        for(int i = 0; i < 5; i++)
        {
            printf("{/*%d*/",i);
            for(int j = 0; j < 6; j++)
            {
                printf("%d,",t[ra].c[i][j]);
            }
            printf("},\n");
        }
        printf("}/*c*/,\n");

        printf("}/*%d*/,\n",ra);
    }
    printf("};\n");

#ifdef SECOND_PASS

    printf("{\n");
    for(ra=0;ra<2;ra++)
    {
        printf("{/*%d*/\n",ra);
        printf("/*a*/%d,\n",t[ra].a);
        printf("{/*b*/");
        for(int i = 0; i < 10; i++)
        {
            printf("%d,",test[ra].b[i]);
        }
        printf("},\n");

        printf("{/*c*/\n");
        for(int i = 0; i < 5; i++)
        {
            printf("{/*%d*/",i);
            for(int j = 0; j < 6; j++)
            {
                printf("%d,",test[ra].c[i][j]);
            }
            printf("},\n");
        }
        printf("}/*c*/,\n");

        printf("}/*%d*/,\n",ra);
    }
    printf("};\n");
#endif

    return(0);
}

it is C so you just get liberal with the curly braces each major element gets its own set, although gcc didn't like the a element having its own.

so.c:19:1: warning: braces around scalar initializer
 {/*a*/10},

and that's part of the exercise, be liberal then back off if it complains.

You can see I added a test to see that the output if the first part can then be used and compiled clean. Then compare the two outputs from the second version to confirm they are the same. (in your case or even mine the output would be pulled into the application and that is where you would test the syntax when that gets compiled, this was just a demonstration for this answer).

And as pointed out you already were doing a use C to init, and you can then use C to make C code...

You just put const up front of the declaration, to make it a const. Since this is const you basically want/need all of the data initialized so this simple approach will work. If you know though that if a = 5 then c isn't used then you can use some of the shortcuts described in other answers/comments. Those ideally will generate zeros for the uninitalized items. Or you can just manually put zeros in there yourself, you are not saving any space in the rom all items are present, just saving space in the embedded application source code with those shortcuts.

For const data like this I get quite verbose, often use code to generate code, and put extra comment data in the code to make it easier to see what that data is, no need to conserve disk space for the source code.

//---- 30 ----
0x00,0x07,0x07,0x07,0x07,0x07,0x00,0x00, //[ #####  ]
0x07,0x07,0x00,0x00,0x07,0x07,0x07,0x00, //[##  ### ]
0x07,0x07,0x00,0x07,0x07,0x07,0x07,0x00, //[## #### ]
0x07,0x07,0x07,0x07,0x00,0x07,0x07,0x00, //[#### ## ]
0x07,0x07,0x07,0x00,0x00,0x07,0x07,0x00, //[###  ## ]
0x07,0x07,0x07,0x00,0x00,0x07,0x07,0x00, //[###  ## ]
0x00,0x07,0x07,0x07,0x07,0x07,0x00,0x00, //[ #####  ]
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, //[        ]
//---- 31 ----
0x00,0x00,0x00,0x07,0x07,0x00,0x00,0x00, //[   ##   ]
0x00,0x00,0x07,0x07,0x07,0x00,0x00,0x00, //[  ###   ]
0x00,0x07,0x07,0x07,0x07,0x00,0x00,0x00, //[ ####   ]
0x00,0x00,0x00,0x07,0x07,0x00,0x00,0x00, //[   ##   ]
0x00,0x00,0x00,0x07,0x07,0x00,0x00,0x00, //[   ##   ]
0x00,0x00,0x00,0x07,0x07,0x00,0x00,0x00, //[   ##   ]
0x00,0x07,0x07,0x07,0x07,0x07,0x07,0x00, //[ ###### ]
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, //[        ]
//---- 32 ----
0x00,0x07,0x07,0x07,0x07,0x07,0x00,0x00, //[ #####  ]
0x07,0x07,0x00,0x00,0x00,0x07,0x07,0x00, //[##   ## ]
0x00,0x00,0x00,0x00,0x00,0x07,0x07,0x00, //[     ## ]
0x00,0x00,0x00,0x07,0x07,0x07,0x00,0x00, //[   ###  ]
0x00,0x07,0x07,0x07,0x00,0x00,0x00,0x00, //[ ###    ]
0x07,0x07,0x00,0x00,0x00,0x07,0x07,0x00, //[##   ## ]
0x07,0x07,0x07,0x07,0x07,0x07,0x07,0x00, //[####### ]
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, //[        ]

(yes that header then compressed into a single bit per pixel header to conserve rom space, depended on how and where I was using it. code generated code, then more code generated more code from that code, then that code was used).

You can of course manually generate the initialization data don't have to programmatically.

Note the

/*a*/ 
/*0*/ 

Stuff was just to make it easier to keep track of what was going on. Indentation really helps as well to see what is going on and you can do it that way too.

const testStruct test[2]=
{
    {
        10,
        {0,1,2,3,4,5,6,7,8,9,},
        {
            {0,1,2,3,4,5,},
            {1,2,3,4,5,6,},
            {2,3,4,5,6,7,},
            {3,4,5,6,7,8,},
            {4,5,6,7,8,9,},
        },
    },
    {
        11,
        {1,2,3,4,5,6,7,8,9,10,},
        {
            {1,2,3,4,5,6,},
            {2,3,4,5,6,7,},
            {3,4,5,6,7,8,},
            {4,5,6,7,8,9,},
            {5,6,7,8,9,10,},
        },
    },
};

Or a combination of both.

Note, some compilers don't like these extra commas so you can easily remove those

this

{3,4,5,6,7,8},

instead of

{3,4,5,6,7,8,},

this

}/*c*/,
}/*1*/
};

instead of this

}/*c*/,
}/*1*/,
};

And you can make this as big as you have hard drive space, granted your target and a number of toolchain tools or editors cant handle infinitely large files. So you will have some limits. Within those limits it all scales.

If you know how to:

const int x = 5;
const float y = 1.5F;
const double z = 2.1;
const char s[]="hello world";
const int a[5]={1,2,3,4,5};

then you basically already know the answer; just be liberal with {curly braces}.

(I am mostly just visualizing other answers/comments).