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?
5 Answers
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.
12 Comments
Joey
Koning Baard XIV: VC even has a
#pragma once which does the same :-)
Kevin Dungs
Also it prevents recursive inclusions... Imagine "alice.h" includes "bob.h" and "bob.h" includes "alice.h" and they don't have include guards...
Keith Thompson
@Јοеу:
#pragma once is not portable; the common #ifndef idiom is recommended.
David Schwartz
@CIsForCookies Punch "one definition rule" into your favorite search engine.
ShadowRanger
The cost of opening a file, discarding all its contents, and closing it over and over might not sound like much, but for a large header included transitively by hundreds of other headers (e.g.
windows.h, the low-level stuff providing simple type definitions like stdint.h, types.h, etc.), the difference between opening it exactly once per source file and opening it a hundred times (where only the first time does anything productive), especially in a parallel build (where even the tiny amount of contention added can hurt a lot on spinning disk storage), adds up in large builds. |
#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
6 Comments
Keith Thompson
Identifiers starting with an underscore are reserved; you shouldn't define them yourself. Use something like
#ifndef H_HEADER_NAME.
Stu
I know this is an old comment, but actually the underscore restriction only applies to "external identifiers" - identifiers that could end up in the compiled object's symbol table, i.e. global variables and function names. It does not apply to macro names.
Will
Is Stu's comment true? I just read stackoverflow.com/questions/228783/… and now I am not so sure.
David Zhao Akeley
No, despite the fact that it is common practice, it is undefined behavior for a user to define any symbol starting with underscore FOLLOWED by an uppercase letter in any scope in C++. In practice such symbols may be used to define macros in the standard libraries, which could collide with user-defined symbols of the same form (I look forward to a response in 2023; greetings, from the age of the rat plague!) Exception: user-defined literals.
NoseKnowsAll
@DavidZhaoAkeley No rat plague here. Underscores followed by uppercase letters are still off-limits, and COVID has dramatically improved around the world :P
|
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.
Comments
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.
#ifndefchecks whetherHEADERFILE_His not declared.#definewill declareHEADERFILE_Honce#ifndefgenerates true.#endifis to know the scope of#ifndefi.e end of#ifndef.
If it is not declared, which means #ifndef generates true, then only the part between #ifndef and #endif is executed, otherwise not. This will prevent from again declaring the identifiers, enums, structure, etc...
Comments
#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 ABOUTSCREEN_H
#define ABOUTSCREEN_H
#include <fcntl.h>
#include <unistd.h>
#define CHARGING_STATUS_FILE "/cable.2/state"
#define LED_ON "255"
#define LED_OFF "0"
namespace Ui
{
class aboutScreen;
}
class aboutScreen : public QWidget
{
Q_OBJECT
public:
enum LedColors
{
OFF,
RED,
BLUE,
GREEN,
WHITE
};
explicit aboutScreen(QWidget *parent = 0, Ui::mainStackWidget *uiMainStackWidget = 0);
~aboutScreen();
void init(void);
void writeLedStatus(QString, QString);
public slots:
void updateBatteryAndStorageStatus(void);
private slots:
void on_backButton_pressed();
void on_backButton_released();
private:
Ui::mainStackWidget *uiMainStackWidget;
};
#endif // ABOUTSCREEN_H
#pragmais: it activates a compiler-specific feature. Although#pragma onceis very widely supported, it's nonstandard.info cppor 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#ifndefidiom so it's as efficient as#pragma once.#ifndef HEADERFILE_Hcan violate the implementation's namespace of the header name happens to start withE; identifiers starting withEand a digit or uppercase letter are reserved to<errno.h>. I suggest#ifndef H_HEADERFILE.