Thread: question regarding predefined macros

[edit] Perhaps I should provide some background here.

Macros can be defined with the preprocessor directive #define. The preprocessor does text substitution (search-and-replace) in the initial stage of compilation. So with a source file like

Code:

#define NUMBER 3

int x = NUMBER;

the compiler (after the preprocessor is finished) sees

Code:

int x = 3;

Macros can be undefined with #undef.

Code:

#undef NUMBER /* nothing here */

Inclosing code in a #if directive causes the code to be removed entirely if the expression is false, or left in place if the expression is true. For

Code:

#if 0
    printf("Hello\n");
#endif

the complier would see nothing; whereas with #if 1 or some other true expression the compiler would see the printf() statement.

Macros can be tested for defined-ness with #if defined(MACRO) or #ifdef MACRO, which are functionally equivalent.

The inverse, of course, is #if !defined(MACRO), which is the same as #ifndef MACRO.

You can also use #elif and #else; and an if-elif-else chain must end with a #endif. There's no #endif after each #if, #elif, and #else -- just one at the end.

Code:

#if VERSION > 2
    #ifdef DEBUG
        whatever
    #elif defined(SOMETHING)
        something
    #endif
#else
    #error Version too old
#endif

As you can see, preprocessor directives can be nested.

Anyway, there's a quick introduction to preprocessor directives. There are lots of others, like #error (which generates a compiler error), #line, which changes the line number, etc. Check some documentation for details. [/edit]

Code:

#if !defined(AFX_LIVEVIDEO_H__70943714_3422_4F6A_B79A_ DD84D6EECF17__INCLUDED_)
#define AFX_LIVEVIDEO_H__70943714_3422_4F6A_B79A_DD84D6EEC F17__INCLUDED_

They are called inclusion guards. They're used to prevent a header file from being included multiple times. The first time a header file is included, the macro is not defined, so the header file defines the macro and then the rest of the header file follows. The following times the header is included, the macro is defined, so #if !defined(MACRO) is false, and the header is equivalent to a blank file.

Inclusion guards can prevent many types of errors and are essential for projects with more than a few header files.

The common idiom (which is exactly the same thing) is

Code:

#ifndef HEADER_H
#define HEADER_H

/* ... */

#endif

Originally Posted by ang_ks

Ok.. so it is just saying that:

since the macros is indeed not include,

define the macros,

and the macros is in fact the rest of the header file.

Is my understanding correct?

Not quite. There are two cases.

The first case is that the header file has not been included before. In this case, the macro is defined as something with the #define statement, and then the rest of the header file follows. The remainder of the header file is completely unrelated to the inclusion guard macro.

Then, if the macro has already been defined, and thus the header file has already been included, the preprocessor removes the code inside the #if !defined() or #ifndef, because the expression was false. All the compiler sees is an empty file, because everything else has been removed.

Note that with the statement

Code:

#define HEADER_H

the macro HEADER_H is being defined as an empty string. The mere fact that it is defined is enough to trigger the inclusion guard. It doesn't have to be defined as anything in particular.

And also you mentioned the common idiom. That means that the macros name can actually be just any name instead of that:

AFX_LIVEVIDEO_H__70943714_3422_4F6A_B79A_ DD84D6EECF17__INCLUDED

Am i right here again?

Thanks a lot dwks.

Yes, macros can indeed be given any name, subject to restrictions, of course. You can only use upper- and lower-case letters, numbers, and underscores; and the first character has to be a letter of either case. You can't use _HEADER_H -- well, you could, but names beginning with _X are reserved -- nor 0something, which could be mistaken for a number, since 12L is a number and 12.324F is a number.

There's a wikipedia entry on inclusion guards, though it isn't very extensive: http://en.wikipedia.org/wiki/Include_guard

Just to clarify the names that are always reserved to the implementation (and hence names that you should not use as your own identifiers)

Each name that contains a double underscore (__) or begins with an underscore followed by an uppercase letter is reserved to the implementation for any use.

Each name that begins with an underscore is reserved to the implementation for use as a name in the global namespace.