What is Conditional Compilation in C plus plus Any simple example?

Answer 1

Conditional compilation is used to exclude code segments from specific builds. For instance, in debug mode you might include additional code such as an assertion macro which you wouldn't really want in the release code.

The following example declares and defines an ASSERT() macro when the program is compiled in debug mode (when DEBUG is defined). In non-debug mode (when DEBUG is not defined), all calls to ASSERT() will be ignored during compilation because there is no implementation provided.

#ifdef DEBUG

#define ASSERT(x) \

if(!(x)) \

{ \

std::cout << "ERROR!! Assert " << #x << " failed\n"; \

std::cout << "on line " << __LINE__ << std::endl; \

std::cout << "in file " << __FILE__ << std::endl; \

}

#else

#define ASSERT( x )

#endif _DEBUG

Within your code you can call ASSERT() to ensure your invariants are true whilst in debug mode:

int x=1, y=1;

ASSERT( x == y );

// .. remainder of code...

In debug mode, the compiler expands the code for you, just as if you'd written the following:

int x=1, y=1;

if(!( x==y ))

{

std::cout << "ERROR!! Assert " << #x << " failed\n";

std::cout << "on line " << __LINE__ << std::endl;

std::cout << "in file " << __FILE__ << std::endl;

}

// .. remainder of code...

But in release mode there is no macro to expand, so the assert is effectively ignored:

int x=1; y=1

// .. remainder of code...

Other uses of conditional compilation include catering for UNICODE or MCBS encoding of strings. If your program uses one or the other, you can use macros to ensure the appropriate string handling calls and declarations are made.

They are also used to "guard" include files to ensure an included file is never included more than once during compilation. This is important when several files include the same file for the purpose of syntax checking. During compilation, however, only one copy of the file needs to be physically included. If multiple inclusions were not guarded against, the compiler would try to include several declarations of the same functions and, even though they all come from the exact same file, the compiler treats them as separate entities and immediately stops the compilation. The same thing occurs when a function is declared twice in two separate files.

// myclass.h

#ifndef _myclass_h_ // First time around, this will not be defined.

#define _myclass_h_ // Now it is defined.

// Declarations (with or without implementations) go here.

#endif _myclass_h_ // Marks the end of the inclusion.

When the compiler "sees" this file for the first time, it will be included because _myclass_h_ would be undefined first time around. But all subsequent inclusions will be ignored because _myclass_h_ was defined during the first inclusion.