How to initialize already defined flexible length array in C? - arrays

Question

Consider the code:
#include <stdio.h>
int a[] = { 1, 2, 3 };
int b[];
int main() {
b = { 4, 5, 6 };
return 0;
}
This of course is illegal.
main.c:7:9: error: expected expression before '{' token
7 | b = { 4, 5, 6 };
| ^
I need to initialize array b in a function. How to do that?
I know one way, but it's... IDK, really?
#include <stdio.h>
int a[] = { 1, 2, 3 };
int b[3];
int main() {
b[0] = 4;
b[1] = 5;
b[2] = 6;
return 0;
}
Is it the only way of doing that?
EDIT:
It's very hard to explain my intent.
Let's say I define items in code. Right? Is that clear? In code, means - it's static, not dynamic. Not runtime. Not "variable length". Let's say it will be 5 items, right? So why don't I just say 5 and set the fixed length to 5?
The reason for this is, I don't have to write:
int a[5] = { 1, 2, 3, 4, 5 };
```c
but instead I can write
```c
int a[] = { 1, 2, 3, 4, 5 };
That saves me the redundant step of counting my items manually, because the compiler counts the items for me. It also allocates the memory on stack for them for me. No need to call malloc.
And here goes the hard to explain part:
Imagine instead of 1, 2, 3, 4 I have structures. They are not numbered, they contain various data types.
Imagine, that later in time I add an additional item to my array, because it will become necessary at a certain point of the project development. To be absolutely clear: this is not by any means dynamic. I will never need a single item more during the runtime. It will be added to the code and committed to Git. And it will stay there, maybe to the end of the program's life.
Imagine I add the item, but I forget to update the items count. It's a super common bug.
The whole point for me is to learn, whether a syntax in C exists allowing to omit the item count by initializing array inside a function. Now I suspect - it is not possible. I can either make such initialization when defining a variable, but not when assigning to the variable, even if it's the only assignment made to that variable.
I'd avoid to allocate more bytes than necessary, also performing more operations than necessary because it's for embedded and I really aim to cut that kind of costs. I also learn how to do the things the correct way, even if I technically could waste some resources.
Additional problem with my real code is some data for the items is not available before a function is called.
So my temporary solution is just to specify the array length. And then remember to update it when I add or remove items DURING DEVELOPMENT. That should work. If it's the correct way of doing that, than it's fine and I'm done. If not, I'd be happy to learn how to do it a better way.

Answer 1

The proper term is variable length array. This is an array whose size is determined by a non-constant expression. Its size is set at execution time when program execution reaches the definition of the array. (“Flexible” is used in the term flexible array member, which is an array that is the last member of a structure and that adapts to the memory allocated for the structure.)
The size of a variable length array must be given where the array is defined, as with int b[n];. You cannot leave the size incomplete, as with int b[];, and specify it later.
C has no grammar for assigning directly to an array. You can assign values to individual elements, and a method for specifying values in aggregate is to use memcpy to copy them from another array, which can be a compound literal:
#include <stdio.h>
#include <string.h>
int main(void)
{
int n = 3;
int b[n];
memcpy(b, (int []) { 4, 5, 6 }, sizeof b);
for (int i = 0; i < 3; ++i)
printf("b[%d] = %d.\n", i, b[i]);
}

Answer 2

The first thing that's wrong is
int b[];
This makes no sense. gcc treats this as the following
int b[1];
This is most definitely wrong. You want
int *b;
Cloning a would be done as follows:
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
size_t size = sizeof( a );
b = malloc( size );
if ( !b ) {
perror( "malloc" );
exit( 1 );
}
memcpy( b, a, size );
Don't forget to free( b );.

Answer 3

Imagine I add the item, but I forget to update the items count.
I think what you're getting at is that you need the size of the array, but you don't want to hardcode it.
No problem. Use this:
int a[] = { 5, 6, 7 };
size_t n = sizeof( a ) / sizeof( *a );
Then you can do stuff like this:
for ( size_t i = 0; i < n ; ++i )
do_this( a[i] );
or
do_that( a, n );
At no point was 3 mentioned, so the code keep working even if you change the initialization of a to the following:
int a[] = { 5, 6, 7, 8 };
The whole point for me is to learn, whether a syntax in C exists allowing to omit the item count by initializing array inside a function
There's nothing special about arrays in functions. Just like outside of functions, you will need to provide a size (int b[...];) or an initializer (int b[] = ...;). Without this, the program wouldn't know how much space to allocate.
But while you say this is the point, it's obviously not. You appear to want to ensure that two arrays are the same size, as you make clear in your following paragraph.
I'd avoid to allocate more bytes than necessary, also performing more operations than necessary because it's for embedded and I really aim to cut that kind of costs. I also learn how to do the things the correct way, even if I technically could waste some resources.
If the array fits on the stack, you can use the following to allocate it on the stack instead of using malloc.
void do_that( int *a, size_t n ) {
int b[n];
...
}
These are called variable length arrays, and it was an addition to C99. (They are variable-length in the sense that every instance of an array created by this code can have a different length. But the created arrays are fixed in size like every C array.)

Answer 4

Imagine I add the item, but I forget to update the items count. It's a super common bug.
The crux of this problem is that you should not code the items count as some constant. Instead use code to calculate to items count value or simply use the size of b[].
#include <assert.h>
#include <string.h>
// Array b exist _someplace_ of some size
void assign_b() {
// Form the initialization list.
same_type_as_b_element b_values[] = { 8, 6, 7, 5, 3, 0, 9 };
// Same size?
static_assert(sizeof b == sizeof b_values), "Mis-matched sizes in b[]");
// Copy to b
memcpy(b, b_values, sizeof b);
}