Are there any options other than using #define for conditional compilation? - c++

Question

I want to use conditional compilation for testing different properties of my code; however, I don't want to pollute the global namespace. Would someone be kind enough to let me know if there is a way to use conditional compilation without using #define?
I have searched for an option, but most of the other posts refer to the usage of static const, etc to choose different code during run-time. I, however, want to compile a different code. For example, instead of:
#define A_HASH_DEFINE
...
#ifdef A_HASH_DEFINE
Some code
#elif ANOTHER_HASH_DEFINE
Some other code
#endif
I would like to be able to use something with a scope, such as:
scope::A_SCOPED_HASH_DEFINE
...
#ifdef scope::A_SCOPED_HASH_DEFINE
Some code
#elif scope::ANOTHER_SCOPED_HASH_DEFINE
Some other code
#endif

Answer 1

If you're using C++17, you should use if constexpr.
It is essentially an if statement where the branch is chosen at compile-time, and any not-taken branches are discarded. It is cleaner than having the #ifdefs splattered throughout your code.
#ifdef _DEBUG
constexpr bool debug_mode = true;
#else
constexpr bool debug_mode = false;
#endif
if constexpr (debug_mode) {
//debug code
}
You can read more about how it replaces #if … #else in FooNathan's blog:
The year is 2017 - Is the preprocessor still needed in C++?

Answer 2

When using preprocessor definitions we always have to deal with the tradeoff that we are polluting the "global namespace".
It's not really the global namespace, of course, but it's own namespace: trouble is, these macro names actually take effect in every scope, due to their nature.
We simply accept this.
We try to limit them by perhaps keeping them to individual translation units. Or, if they need to be in a header, we switch to const bools instead.
If you need conditional compilation in the truest sense and you can spell this in non-preprocessor C++ using if constexpr, then so much the better.
Otherwise it's just something we have to deal with. We at least try to use descriptive names and avoid using common terms that may conflict with third-party headers. If/when they do, we change them.
If you're still finding that your macros are too polluting, then it could be that your switching logic encapsulates too much code. In such a case, you may consider moving the logic into your build system and changing which source files you build in the first place.
For example, an OpenGL renderer implementation versus a DirectX renderer implementation (an example that only works if you switch between these at build time, as you would be with a macro!).

Answer 3

When dealing with conditional compilation it is very common to omit declaring the define at compile time, a nice trick to make it more type-safe is to use an enumeration (a boolean value may also work) to ensure a valid value is defined at compile time.
Example
enum class SystemEnum { MAC, LINUX, WINDOWS };
const SystemEnum mySystem = SystemEnum::MY_SYSTEM;
void func() {
#if MY_SYSTEM == MAC
doMacStuff();
#elif MY_SYSTEM == LINUX
doLinuxStuff();
#elif MY_SYSTEM == WINDOWS
doWindowsStuff();
#else
#error "You must define MY_SYSTEM to compile this"
#endif
if constexpr (mySystem == SystemEnum::MAC)
doMacStuff();
else if constexpr (mySystem == SystemEnum::LINUX)
doLinuxStuff();
else if constexpr (mySystem == SystemEnum::WINDOWS)
doWindowsStuff();
else
doError();
}