Initialize a global with a global from another file

Question

hi,
I know that initialization order for global variables across compilation units is not defined, but if I have
file1.cpp
  int x0 = 33, x1 = 55;
  extern int y0, y1;
  static int a[] = { y0, y1 };
  void print_a( void ) { printf( "\na[0] = %d\na[1] = %d", a[0], a[1] ); }
  extern void print_b( void );
  main()
    print_a();
    print_b();
and file2.cpp
  int y0 = 77, y1 = 99;
  extern int x0, x1;
  static int b[] = { x0, x1 };
  void print_b( void ) { printf( "\nb[0] = %d\nb[1] = %d", b[0], b[1] ); }
I notice that values are displayed correctly and consequently, initialized in the order I need. So what's the secret, coincidence, am I lucky? Does it make any difference if file2.cpp is part of a static library?
Thanks

Answer 1

@ Igor Tandetnik: Yes, I chose an example with circular dependency just to show that it was not the situation that, by luck, the "other" file was was initialized first. Yes, I would like a solution for such circular dependency, but I hope that I will
find, at least, a solution for the case when such circular dependency does not exist. What I want to achieve? As the title says, I want a solution to be able to initialize globals with globals from another file, a solution as general and fault proof and convenient
as possible.
@ Wyck: I thought about something like that, problem is that in case of large arrays there is a lot to type. Another solution (it saves a little typing) I saw was something like
// common_header.h
#define LIST_A  y0, y1
#define LIST_B  x0, x1
// file1.cpp
#include "common_header.h"
Number x0(33), x1(55);
static Number a[] = { LIST_A };  // just to give correct size
// file2.cpp
#include "common_header.h"
Number y0(77), y1(99);
static Number b[] = { LIST_B }; // just to give correct size
// init.cpp
extern Number LIST_A, LIST_B;
void init()
{  Number a_[] = { LIST_A };   Number b_[] = { LIST_B }; // stack usage
   for( int i = 0; i <_countof( a_ ); i++ )  a[ i ] = a_[ i ];
   for( int i = 0; i <_countof( b_ ); i++ )  b[ i ] = b_[ i ];
This still has the problem of using much stack in case of large arrays and if array members are more complex structures (might also contain string literals), there is a bit more difficult.
Bellow is a solution I came up with using macros but which I don't really like because is a bit cumbersome. I'm looking for something better/more elegant/safer or simply I want to see what other solutions people see here.
// file1.cpp -------------------------------------------
#define MEMBER_LIST( Usage ) \
Usage( x1 ) \
Usage( x2 )
#define IMPORT( ext_member ) extern Number ext_member;
#define COUNT( member ) 1 +
#define LOAD( member_val ) a[ i++ ] = member_val;
Number y1 = 77, y2 = 99;
MEMBER_LIST( IMPORT )
static Number a[ MEMBER_LIST( COUNT ) 0 ];
static void InitGlobals_a( void ) { uint8 i = 0; MEMBER_LIST( LOAD ) }
extern void InitGlobals_b( void );
int _tmain(int argc, _TCHAR* argv[])
{ InitGlobals_a();  InitGlobals_b();
return 0;
// file2.cpp -------------------------------------------
#define MEMBER_LIST( Usage ) \
Usage( y1 ) \
Usage( y2 )
#define IMPORT( ext_member ) extern Number ext_member;
#define COUNT( member ) 1 +
#define LOAD( member_val ) b[ i++ ] = member_val;
Number x1 = 33, x2 = 55;
MEMBER_LIST( IMPORT )
static Number b[ MEMBER_LIST( COUNT ) 0 ];
void InitGlobals_b( void ) { uint8 i = 0;  MEMBER_LIST( LOAD ) }
Of course, something like
#define MEMBER_LIST( Usage ) Usage( x1 ) Usage( x2 )
could be further simplified using other macros so you can simple use
#define MEMBER_LIST x1, x2
but those additional macros will add up to the complexity.