#define

You can use the #define directive to give a meaningful name to a constant in your program. The two forms of the syntax are:

Syntax :#define identifier token-string

#define identifier[( identifier, ... , identifier )] token-string

The #define directive substitutes token-string for all subsequent occurrences of an identifier in the source file.

#error

Syntax :#error token-string

When #error directives are encountered, compilation terminates. These directives are most useful for detecting programmer inconsistencies and violation of constraints during preprocessing.

Example :

Code:

#if !defined(__cplusplus)
#error C++ compiler required.
#endif

#undef

As its name implies, the #undef directive removes (undefines) a name previously created with #define.

Syntax

#undef identifier

#if, #elif, #else, #endif

The #if directive, with the #elif, #else, and #endif directives, controls compilation of portions of a source file. If the expression you write (after the #if) has a nonzero value, the line group immediately following the #if directive is retained in the translation unit.

Syntax

Code:

#if
line text
#elif
line text
#else
line text
#endif

#include

The #include directive tells the preprocessor to treat the contents of a specified file as if those contents had appeared in the source program at the point where the directive appears.

Syntax

#include "path-spec"

This form instructs the preprocessor to look for include files in the same directory of the file that contains the #include statement

#include <path-spec>

This form instructs the preprocessor to search for include files first along the path specified by the /I compiler option, then along the path specified by the INCLUDE environment variable.

#ifdef, #ifndef

The #ifdef and #ifndef directives perform the same task as the #if directive when it is used with defined( identifier ).

Syntax

#ifdef identifier

#ifndef identifier

is equivalent to

#if defined identifier

#if !defined identifier

#pragma

Each implementation of C and C++ supports some features unique to its host machine or operating system. Some programs, for instance, need to exercise precise control over the memory areas where data is placed or to control the way certain functions receive parameters. The #pragma directives offer a way for each compiler to offer machine- and operating-system-specific features while retaining overall compatibility with the C and C++ languages. Pragmas are machine- or operating-system-specific by definition, and are usually different for every compiler.

Instead of going into the details of what each one of them is I would discuss the most commonly used one here as thats the title of the article and that is once.

It specifies that the file, in which the pragma resides, will be included (opened) only once by the compiler in a building of a particular file.

#pragma once

There is one big confusion among the developers that header file is included once if it contains #pragma once only for the entire build but actually thats not the case. When you have two files code1.cpp and code2.cpp and one header file header.h. Put #pragma once and then a variable declaration in the header file as int iTest = 10; and try including the header file from both the cpp files and you will see an error like iTest already defined in xxxx.obj.

This is not because #pragma is not working but actually the concept is for the compilation of the .cpp file a header file can be included multiple times from different locations and that is prevented using the #pragma once