struct member array size based on const int across files

Question

So I want to have a definition of the size of an array within a struct known at compile time. I would also like that number available as a variable for ease of use later. What I have is the following:

const int BANANA_ARRAY_SIZE = 10;

typedef struct
{
  char bananas[BANANA_ARRAY_SIZE];
  int some_other_stuff;
} banana_struct;

This functions fine. However, if I have it in a .h file that gets included in multiple places, the compiler complains about redefinition of BANANA_ARRAY_SIZE (which makes sense). So I need to declare it as an extern so multiple compilation units can know about it.

So, I now have

extern const int BANANA_ARRAY_SIZE;

typedef struct
{
  //.. same as before
} banana_struct;

and in an implementation file I have

const int BANANA_ARRAY_SIZE = 10;

But now the compiler won't let me define the struct anymore with complaints of

fields must have a constant size: variable length array in structure

Is there any way I can achieve what I want (have length of array stored in variable and used to define struct)?

Edit:

In response to the suggestions to instead use #defines, I'd rather not.

My question is about how to have this constant value stored in a variable and also used to set the length of an array in a struct. If you need further justification, assume I need a function that takes a pointer to an int. Can't take a reference of a #define.

Answer 1

In C language const object is not a constant. You cannot use it to declare a non-VLA array. Your first declaration is not compilable in C language, which makes it unclear what you mean by "functions fine".

See here for more details: Shall I prefer constants over defines?

In your case you are restricted to either #define or enum constants. If you also want to create pointers to that value, you will have to additionally declare a const object with the same value, either globally or locally as needed. But you won't be able to use it in non-VLA array declarations. Instead, you will have to use the #define or enum constant. E.g.

// In .h file
#define BANANA_ARRAY_SIZE 10
extern const int BANANA_ARRAY_SIZE_OBJ;

// In .c file
const int BANANA_ARRAY_SIZE_OBJ = BANANA_ARRAY_SIZE;

Answer 2

You can either use a enum or a #define

enum {
BANANA_ARRAY_SIZE = 10
};

or

#define BANANA_ARRAY_SIZE 10

Answer 3

You must use extern for that, so it's not redifined, and you will need to define it once in a single .c file.

Example

1. header.h

   extern const int BANANA_ARRAY_SIZE;
   

2. main.c¹

   void banana(void); /* provide a prototype for `banana()' */
   /* A single definition */
   const int BANANA_ARRAY_SIZE = 10;
   
   int main(void)
    {
       banana();
       return 0;
    }
   

---

¹_{This is for demonstration purpose, you don't just add the prototypes in real life, you must care about the source code layout and ensure that the prototype matches the function definition, etc.}

3. banana.c

   #include "header.h"
   #include <stdio.h>
   
   void banana(void)
    {
       printf("%d\n", BANANA_ARRAY_SIZE);
    }
   

Compiling with

gcc -Wall -Werror -o banana banana.c main.c    

when executed will print 10.

But I would recommend a macro instead, like

#define BANANA_ARRAY_SIZE 10

then you can even defined it at compile time like

gcc -DBANANA_ARRAY_SIZE=10 a.c b.c d.c -o executable

to prevent redefinition or no definition at all a common header file would contain

#ifndef BANANA_ARRAY_SIZE
#define BANANA_ARRAY_SIZE 10
#endif

Answer 4

According to C11 draft 6.6#10, "An implementation may accept other forms of constant expressions.".

Tried that with gcc 4.8.2:

static const size_t arr_size = 10;  // static does not change anything
static int arr[arr_size];           // dito

---

gcc -std=gnu11 -Wall test.c

test.c:6:12: error: variably modified ‘arr’ at file scope
static int arr[arr_size];

So that does not work (would have surprized me if it had). Even if id worked, it would be implemenation defined and might change even between two patches for the same compiler.

There is a clear reason for this not working, expecially if the const has global scope: If a module is compiled which includes the header with the declaration, the compiler has no way to knwo the actual value of that constant variable(!). So how would it reserve space for the array in .bss section or be able to check for ranges if initializers are given (and alloc space in .data section)? That would require intervention by the linker and would have much more impact on initializers, etc. I'm quite sure no compiler will accept this for the reasons given.

---

So, you have to resort to using #define:

"array.h":
#define MAX_ARR_LEN 10
extern const size_t max_arr_len;

"array.c":
const size_t max_arr_len = 10;

Note: use size_t for array bounds. That's what it is for (among others).