In this post, I will introduce the difference between include guard and As usual, I will present the conclusion first. <\/p>\n Preprocessors are programs that process our source code before compilation and linking. There are different types of preprocessor directives: <\/p>\n The preprocessor is executed at translation phase 4<\/a>, before the compilation. Typically the preprocessor will first recursively replace all The files by As introduced in the above subsection, a translation unit is the output of the preprocessor. From a translation unit, the compiler generates an object file, which can be further processed and linked (possibly with other object files) to form an executable program.<\/p>\n As you may notice, the preprocessor will recursively replace all For example, <\/p>\n Here, the first inclusion of "grandparent.h" causes the macro GRANDPARENT_H to be defined. Then, when "child.c" includes "grandparent.h" the second time, the #ifndef test returns false, and the preprocessor skips down to the #endif, thus avoiding the second definition of struct foo. The program compiles correctly. <\/p>\n In order for If it appears in a header file, it indicates that it is only to be parsed once, even if it is (directly or indirectly) included multiple times in the same source file.<\/p>\n Unlike include guards, For example, <\/p>\n This will work since However, <\/p>\n This will violate the One Definition Rule. <\/p>\n Wikipedia Pragma Once<\/a> Summary In this post, I will introduce the difference between include guard and #pragma directives in C++. Conclusion As usual, I will present the conclusion first. Include guard is the standard way to prevent multiple inclusion of the same header; #pragma directive is not required by C++ standard but now widely supported by most of…<\/p>\n","protected":false},"author":1,"featured_media":0,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[6,5],"tags":[],"class_list":["post-587","post","type-post","status-publish","format-standard","hentry","category-c","category-proglang"],"_links":{"self":[{"href":"https:\/\/nanzhou.cc\/index.php\/wp-json\/wp\/v2\/posts\/587","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/nanzhou.cc\/index.php\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/nanzhou.cc\/index.php\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/nanzhou.cc\/index.php\/wp-json\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/nanzhou.cc\/index.php\/wp-json\/wp\/v2\/comments?post=587"}],"version-history":[{"count":10,"href":"https:\/\/nanzhou.cc\/index.php\/wp-json\/wp\/v2\/posts\/587\/revisions"}],"predecessor-version":[{"id":598,"href":"https:\/\/nanzhou.cc\/index.php\/wp-json\/wp\/v2\/posts\/587\/revisions\/598"}],"wp:attachment":[{"href":"https:\/\/nanzhou.cc\/index.php\/wp-json\/wp\/v2\/media?parent=587"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/nanzhou.cc\/index.php\/wp-json\/wp\/v2\/categories?post=587"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/nanzhou.cc\/index.php\/wp-json\/wp\/v2\/tags?post=587"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}#pragma<\/code> directives in C++. <\/p>\nConclusion<\/h2>\n
\n
#pragma<\/code> directive is not required by C++ standard but now widely supported by most of the compilers, including GCC and clang. <\/li>\n\/\/ use this one\n#ifndef LIBRARY_FILENAME_H\n#define LIBRARY_FILENAME_H\n\/\/ contents of the header\n#endif \/* LIBRARY_FILENAME_H *\/<\/code><\/pre>\n#pragma once\n\/\/ contents of the header<\/code><\/pre>\n<\/li>\n<\/ol>\nDetails<\/h2>\n
Preprocessors<\/h3>\n
\n
#include<\/code> directives with the literal file declared in the directive (usually header files, but possibly other source files); the result of this step is a preprocessing translation unit. Then it will handle macro expansion<\/a> of #define<\/code> directives, and (conditional compilation)[https:\/\/en.wikipedia.org\/wiki\/Object_file<\/a>] of #ifdef<\/code> directives, among others; this translates the preprocessing translation unit into a translation unit.<\/p>\n#include<\/code> directives are generally header files, which typically contain declarations of functions and classes or structs.<\/p>\nTranslation Unit<\/h3>\n
Include Guard<\/h3>\n
#include<\/code> directives with the literal files. There may be the case that certain classes or functions are defined twice. The resulting translation unit is invalid. See One Definition Rule<\/a> for details.<\/p>\n#include<\/code> guards prevent this erroneous construct from arising by the double inclusion mechanism.<\/p>\n\/\/File "grandparent.h"\n#ifndef GRANDPARENT_H\n#define GRANDPARENT_H\n\nstruct foo {\n int member;\n};\n\n#endif \/* GRANDPARENT_H *\/<\/code><\/pre>\n\/\/File "parent.h"\n#include "grandparent.h"<\/code><\/pre>\n\/\/File "child.c"\n#include "grandparent.h"\n#include "parent.h"<\/code><\/pre>\n\/\/Result\nstruct foo {\n int member;\n};<\/code><\/pre>\n#include<\/code> guards to work properly, a project using must work out a coherent naming scheme for its include guards, and make sure its scheme doesn’t conflict with that of any third-party headers it uses, or with the names of any globally visible macros.<\/p>\nPragma Once<\/h3>\n
#pragma once<\/code> makes it impossible to erroneously use the same macro name in more than one file. On the other hand, since with #pragma once files are excluded based on their filesystem-level identity, this can’t protect against including a header twice if it exists in more than one location in a project (this will happen when someone copy and paste codes).<\/p>\n\/\/File "grandparent.h"\n#ifndef GRANDPARENT_H\n#define GRANDPARENT_H\n\nstruct foo {\n int member;\n};\n\n#endif \/* GRANDPARENT_H *\/<\/code><\/pre>\n\/\/File "dir\/grandparent.h"\n#ifndef GRANDPARENT_H\n#define GRANDPARENT_H\n\nstruct foo {\n int member;\n};\n\n#endif \/* GRANDPARENT_H *\/<\/code><\/pre>\n\/\/File "parent.h"\n#include "grandparent.h"<\/code><\/pre>\n\/\/File "child.c"\n#include "grandparent.h"\n#include "dir\/grandparent.h"\n#include "parent.h"<\/code><\/pre>\ngrandparent.h<\/code> and dir\/grandparent.h<\/code> has the same signature GRANDPARENT_H<\/code>. <\/p>\n\/\/File "grandparent.h"\n#pragma once\nstruct foo {\n int member;\n};<\/code><\/pre>\n\/\/File "dir\/grandparent.h"\n#pragma once\nstruct foo {\n int member;\n};<\/code><\/pre>\n\/\/File "parent.h"\n#include "grandparent.h"<\/code><\/pre>\n\/\/File "child.c"\n#include "grandparent.h"\n#include "dir\/grandparent.h"\n#include "parent.h"<\/code><\/pre>\nReference<\/h2>\n
\nWikipedia Include Guard<\/a>
\ncppreference<\/a><\/p>\n","protected":false},"excerpt":{"rendered":"