Filling an integer array from global variables then returning it from a function in C

Question

There are a number of global variables, let's say for example someglobalvalue1, someglobalvalue2, etc, that are updated dynamically from a different part of the app I'm working on. In the part that I am currently working on, I need to gather these variables into an integer array. Because there are a lot of these variables in different groups, I have separate functions like GetGroupOne(), GetGroupTwo(), etc to insert the globals into an array and return it to the main function. I'm using this page as a guide for how to return int arrays from functions: http://www.tutorialspoint.com/cprogramming/c_return_arrays_from_function.htm

So for example:

int main() {
   int *array;
   array = GetGroupOne();
   /* do stuff with array */
   return 0;
}

int * GetGroupOne() {
  static int array[GROUP_ONE_LENGTH] = { someglobalvalue1, someglobalvalue2, someglobalvalue3 };

  return array;
}

So, trying to compile this (by the way, I am limited to a C90 compiler) gets me this error:

Error “initializer element is not constant” when trying to initialize variable with const

So, I did find Error "initializer element is not constant" when trying to initialize variable with const and other threads that seemed to suggest that what I was trying to do, initialize using globals, is not possible. So I bit the bullet and did this instead:

int * GetGroupOne() {
  static int array[GROUP_ONE_LENGTH];
  array[0] = someglobalvalue1;
  array[1] = someglobalvalue2;
  array[2] = someglobalvalue3;
  /* etc... */

  return array;
}

Now, this works but it is incredibly ugly and it hurts my soul to look at it. Especially because there are multiple groups, some of which have over a hundred entries, so I have to insert each global into the array individually. I know how I would handle this in higher level languages, but C is still somewhat of a mystery to me. But I'm thinking there MUST be some better way to handle this problem. Can anyone nudge me in the right direction?

Thank you.

Answer 1

Putting aside my own soul's pain over a design that calls for hundreds of global variables, there is at least one way to improve the look of your implementation, using a function with a variable-length argument list. It would look something like this (untested):

  #include <stdarg.h>
  int * CompileIntegerArray( int *dest, unsigned int count, ... ) {
    int *put = dest;
    va_list arglist;
    va_start( arglist, count );
    for( ; count != 0; --count ) {
      *put++ = va_arg( arglist, int );
    }
    va_end( arglist );
    return dest;
  }

...

  int * GetGroupOne() {
    static int array[GROUP_ONE_LENGTH];
    return CompileIntegerArray( array, GROUP_ONE_LENGTH,
      someglobalvalue1, 
      someglobalvalue2, 
      someglobalvalue3 
      );
  }

Realize that there are terrible things about what you are doing, though. At a minimum, whenever a group changes length you have to update the length and ensure that the right number of variables are in the call to CompileIntegerArray, or risk introducing delayed stack bombs into your code.

There are of course some (minor) performance implications to this approach, and some compilers might choke on hundreds of arguments to a function call.

[Edited to add an alternative]

There's another thing you can do that will improve the look a little bit and still make it easier to change the order of the array elements. It is somewhat faster, and does not rely on a separate function to process the array. This will also give you the opportunity to do some error checking. Use the preprocessor:

#define _el(x) array[ index++ ] = x;

int * GetGroupOne() {
  static int array[GROUP_ONE_LENGTH];
  int index = 0;

  _el( someglobalvalue1 )
  _el( someglobalvalue2 )
  _el( someglobalvalue3 )

  if( index != GROUP_ONE_LENGTH ) {
    puts( "GAAK!" );
    exit(1);
  }
  return array;
}

Answer 2

One option is to make your static array contain pointers to the global variables (which does count as a compile-time constant):

int **get_group_one(void)   // (void) instead of () is important
{
// note the `const`, your system will love you for it
// could also add a compile-time test that you actually do have GROUP_ONE_LENGTH entries
static int *const array[GROUP_ONE_LENGTH] = { &global0, &global1, &global2 };

    return array;
}

and then access your globals via a macro

#define G1(n) ( *(get_group_one()[n])  )

You could add some error checking to avoid undefined behaviour on range errors, if you try G1(n) where n is out of range then you either access a dummy variable, or call an error handler, etc.

If your compiler supports inline functions then that would be tidier than a macro.

BTW is there any reason you can't just have your global variables be in an array in the first place?