C++ Idiom for executing arbitrary code before main in arbitrary translation unit

Question

I have one translation unit with my main() function and another TU without main. Suppose even that I only control the second one and can't touch the first one.

Now, for reasons I will not go into, I want to be able to run some code before main() runs. I know this can be done by initializing a global variable with a function call, but I want to hide this - with as little use of macros as possible (dare I say no use of macros? probably impossible, there's no proper static block in C++)

What would be an elegant, or shall we say, not-very-ugly way of doing this? To be more clear, I'm looking for something which would provide this functionality for use multiple times, not just something to get it to work once. I want it to be as close to:

// ... at global scope ...
static {
    // my code here
}

PS: This question is related, but not the same, as this question about initializing static class members. It's also motivated by the wish to clearly disprove this claim it can't be done in C++.

Note: Yes, I know about the static initialization order fiasco, no need to remind me of it... and I'm not asking for something which bypasses it. Obviously running code statically requires some prudence.

Answer 1

Please enjoy the static initialization order fiasco:

int f(/* whatever args you want*/)
{
    // code to be ran before main()
    return 42;
}

static int _ignore = f(/*...*/);

---

Note that on occasion the code might not be called, if not used anywhere else (alias "optimized out"). One of such case is when the TU is compiled into a static library (then the unused variable and the code might not be pulled into the executable). (note of E. Maskovsky).

Answer 2

This is the best I could come up with so far. It works, but the implementation is kind of fugly.

Usage

If you write:

STATIC_BLOCK {
    std::cout << "Hello static block world!" << std::endl;
}

this code will run before your main(). However, note that writing to std::cout before main() begins is not actually such a great idea.

Notes:

• You must surround your static block code with curly braces (no need for a trailing semicolon; thanks @KlitosKyriacou for the suggestion).
• If you don't use curly braces, expect hard-to-figure-out error messages.
• The relative order of execution of static code is not guaranteed in C++.

Implementation

The static block implementation involves a dummy variable. To ensure we don't collide with some other dummy variable (e.g. from another static block - or anywhere else), we need a bit of macro machinery.

#define CONCATENATE(s1, s2) s1##s2
#define EXPAND_THEN_CONCATENATE(s1, s2) CONCATENATE(s1, s2)

#define STATIC_BLOCK_IMPL2(function_name,var_name) \
static void function_name(); \
static int var_name __attribute((unused)) = (function_name(), 0) ; \
static void function_name()

#define STATIC_BLOCK_IMPL1(prefix) \  
    STATIC_BLOCK_IMPL2(CONCATENATE_FOR_STATIC_BLOCK(prefix,_fn),CONCATENATE_FOR_STATIC_BLOCK(prefix,_var))

#define STATIC_BLOCK STATIC_BLOCK_IMPL1(EXPAND_THEN_CONCATENATE(static_block_,__COUNTER__))

Notes:

• If your compiler does not support __COUNTER__ (as it's an extension to the standard, not part of it) - you can use __LINE__, which works too. GCC and Clang support __COUNTER__.
• __attribute__((unused)) is another compiler extension, although attributes have been coming into the language; see this discussion for example. If you drop it you'll get a warning.
• The code is C++98 (ignoring the compiler extensions), i.e. you don't need any modern C++ constructs supported. Unfortunately it doesn't qualify as C (where initializers must be constants).

---

_{Originally inspired by Andrei Alexandrescu's SCOPE_EXIT trick.}