How to define extern variable within function

Because you're using the extern keyword, what you have in your header file is a declaration, not a definition. It states that a given variable exists but it doesn't actually define it. Without a definition, you get the "undefined reference" error during the linking phase.

Also, if you're "initializing" the array inside of a function, that's not actually initialization but assignment. Initialization only occurs at the point a variable is defined. And because the elements of the array are being assigned to, even if they're never changed after that, you can't declare it const.

If the only functions that access the array reside in the same source file, then there's no need to declare it in a header file. Just define it (i.e. without extern) in the source file. You'll also need to leave off const since the initialization functions needs to assign to it. Using static would also be a good idea in this case so that the array's name isn't visible in any other source files.

As a matter of encapsulation, you might want to put the array and those two functions in a source file by themselves. That way you know that only those two functions can directly access the array.

Answer A: It’s a global

The extern keyword is used to tell the compiler that some global variable exists elsewhere in the code (usually a separate translation unit, which you can think of as a .c/.h → object file that gets linked into the final executable/binary).

Hence, the variable is a global and must simply be initialized before use:

// these exist elsewhere:
extern some_type global_variable;
void initialize_global_variable();

// this exists here:
int main()
{
  initialize_global_variable();
  ...
  do_something_with( global_variable );

I can see how this is unsatisfying because the initialization of the global is not very automatic or encapsulated. But it is the way C is designed, and works fine.

Answer B: Restrict access via function call

The other option is to encapsulate the variable as a static local in a function, and initialize it on first use.

some_type get_variable()
{
  static bool is_initialized = false;
  static some_type variable;
  if (!is_initialized)
  {
    ...
    is_initialized = true;
  }
  return variable;
}

Thereafter you can call the function every time you want the value:

some_type get_variable();

int main()
{
  do_something_with( get_variable() );

The only downside to this one is the check for initialization every time the value is used.