Why are #ifndef and #define used in C++ header files?
I have been seeing code like this usually in the start of header files:
#ifndef HEADERFILE_H
#define HEADERFILE_H
And at the end of the file is
#endif
What is the purpose of this?
#pragma is: it activates a compiler-specific feature. Although #pragma once is very widely supported, it's nonstandard.
info cpp or look here) says "it is not recognized by all preprocessors, so you cannot rely on it in a portable program.". And GNU cpp optimizes the common and portable #ifndef idiom so it's as efficient as #pragma once.
#ifndef HEADERFILE_H can violate the implementation's namespace of the header name happens to start with E; identifiers starting with E and a digit or uppercase letter are reserved to <errno.h>. I suggest #ifndef H_HEADERFILE.
Those are called #include guards.
Once the header is included, it checks if a unique value (in this case HEADERFILE_H) is defined. Then if it's not defined, it defines it and continues to the rest of the page.
When the code is included again, the first ifndef fails, resulting in a blank file.
That prevents double declaration of any identifiers such as types, enums and static variables.
#ifndef <token>
/* code */
#else
/* code to include if the token is defined */
#endif
#ifndef checks whether the given token has been #defined earlier in the file or in an included file; if not, it includes the code between it and the closing #else or, if no #else is present, #endif statement. #ifndef is often used to make header files idempotent by defining a token once the file has been included and checking that the token was not set at the top of that file.
#ifndef _INCL_GUARD
#define _INCL_GUARD
#endif
#ifndef H_HEADER_NAME.
This prevent from the multiple inclusion of same header file multiple time.
#ifndef __COMMON_H__
#define __COMMON_H__
//header file content
#endif
Suppose you have included this header file in multiple files. So first time __COMMON_H__ is not defined, it will get defined and header file included.
Next time __COMMON_H__ is defined, so it will not include again.
They are called ifdef or include guards.
If writing a small program it might seems that it is not needed, but as the project grows you could intentionally or unintentionally include one file many times, which can result in compilation warning like variable already declared.
#ifndef checks whether HEADERFILE_H is not declared.
#define will declare HEADERFILE_H once #ifndef generates true.
#endif is to know the scope of #ifndef i.e end of #ifndef
If it is not declared which means #ifndef generates true then only the part between #ifndef and #endif executed otherwise not. This will prevent from again declaring the identifiers, enums, structure, etc...
Follow WeChat
Success story sharing
Want to stay one step ahead of the latest teleworks?
Subscribe Now相似问题
- What are the differences between a pointer variable and a reference variable?
- Why use apparently meaningless do-while and if-else statements in macros?
- When should static_cast, dynamic_cast, const_cast, and reinterpret_cast be used?
- Why can templates only be implemented in the header file?
- What is the copy-and-swap idiom?
- What does the ??!??! operator do in C?
- Why are elementwise additions much faster in separate loops than in a combined loop?
- Why is processing a sorted array faster than processing an unsorted array?
#pragma oncewhich does the same :-)#pragma onceis not portable; the common#ifndefidiom is recommended.#pragma onceis explicit; it says "once I've been#included in a given translation unit, don't open this file again". Include guards say "If I'm included again, skip my contents" (but the file is still logically opened, read from end to end, and the guard drops the contents). I haven't checked on recent compilers, but for a while, GCC recognized the include guard idiom and implicitly did what#pragma oncedoes, while MSVC didn't, so if you didn't#pragma oncetoo, you'd open and process the file repeatedly, adding syscall overhead.