C preprocessor: redefine macro, macro overload

The following code has a FLAG controlled macro to use func1 or func2 when compiling. I want to make it switch between the 2 function when compiling by using the "FLAG" macro (defining/undefining) as it's done on main(). This is just a sample/example, the usage will be across multiple files.

My question is that this only executes func1() as the preprocessor have assigned the symbol to func_wrapper and I'm not changing it. Also if if do #undef func_wrapperit will be required to redefine it by adding more code.

My question is if it is possible to achieve that without having the redefine of func_wrapper each time. It something like making the preprocessor do another pass over the macros when the FLAG is undefined and check again the defines that where defined under.

I want to get something that looks like the following code:

#include "functions.h"
#include "functions2.h"

#define FLAG

#ifdef FLAG
#define func_wrapper func1
#endif


#ifndef FLAG
#define func_wrapper func2
#endif


int main(){

	func_wrapper();


	#undef FLAG

	func_wrapper();

}

and runs like the follwing one:

...
//same as previous one
...
int main(){

	func_wrapper();


	#undef FLAG
	#ifndef FLAG
    #undef func_wrapper
	#define func_wrapper func2
	#endif

	func_wrapper();

}

> if it is possible to achieve that without having the redefine of func_wrapper each time

No.

> making the preprocessor do another pass over the macros

You have to type out that another pass.

#include "functions.h"
#include "functions2.h"

#define FLAG

#ifdef FLAG
#define func_wrapper func1
#else
#define func_wrapper func2
#endif

int main() {
    func_wrapper();
    #undef FLAG
#undef func_wrapper
#ifdef FLAG
#define func_wrapper func1
#else
#define func_wrapper func2
#endif
    func_wrapper();
}

You can put that in a header.

// resolve_flag.h
#ifdef func_wrapper
#undef func_wrapper
#endif
#ifdef FLAG
#define func_wrapper func1
#else
#define func_wrapper func2
#endif

// main.h
#include "functions.h"
#include "functions2.h"

#define FLAG
#include "resolve_flag.h"

int main() {
    func_wrapper();
    #undef FLAG
    #include "resolve_flag.h"    
    func_wrapper();    
}

But maybe just use runtime and some global state:

bool flag = 0;
void func_wrapper(void) {
     flag ? func1() : func2();
}

int main() {
     func_wrapper();
     flag = 1;
     func_wrapper();
}

If func_wrapper is not originally a macro, you can redefine it to something else with only one line of source:

#include "functions.h"
#include "functions2.h"

// default definition.  We can use macros to have some callers call func2 directly
static inline void func_wrapper() {
  func1();
}
// #define func_wrapper func2


int main()
{
    func_wrapper();    //  call func1
    #define func_wrapper func2
    func_wrapper();    //  call func2

    #undef func_wrapper  // now it's back to an alias for func1
}

This is rather ugly and seems pretty hacky, and loses the separate name of FLAG which presumably has some useful semantic meaning. I wouldn't recommend doing this.

If the function actually takes args, your wrapper would have to pass them on.

You actually don't need CPP at all if you can use nested functions, a GNU C extension. This works in GCC but not clang (Godbolt).

// default definition
static inline void func_wrapper() {
  func1();
}

int main()
{
    func_wrapper();

    static inline void func_wrapper(){ func2(); }  // shadows the global definition

    func_wrapper();
}

This is even worse, since the wrapper definition clutters up the function you're using it inside.