I personally follow Boost’s recommendation. It’s perhaps one of the largest collection of C++ libraries of good quality around and they don’t have problem. It goes like: <project>_<path_part1>_…_<path_partN>_<file>_<extension>_INCLUDED // include/pet/project/file.hpp #ifndef PET_PROJECT_FILE_HPP_INCLUDED which is: legal (note that beginning by _[A-Z] or containing __ is not) easy to generate guaranteed to be unique (as a include … Read more
A directive like #pragma once is not trivial to define in a fully portable way that has clear an unambiguous benefits. Some of the concepts for which it raises questions are not well defined on all systems that support C, and defining it in a simple way might provide no benefit over conventional include guards. … Read more
The guard header (or more conventionally “include guard”) is to prevent problems if header file is included more than once; e.g. #ifndef MARKER #define MARKER // declarations #endif The first time this file is #include-ed, the MARKER preprocessor symbol will be undefined, so the preprocessor will define the symbol, and the following declarations will included … Read more
foo.h #ifndef FOO_H_ /* Include guard */ #define FOO_H_ int foo(int x); /* An example function declaration */ #endif // FOO_H_ foo.c #include “foo.h” /* Include the header (not strictly necessary here) */ int foo(int x) /* Function definition */ { return x + 5; } main.c #include <stdio.h> #include “foo.h” /* Include the header … Read more
The FILENAME_H is a convention. If you really wanted, you could use #ifndef FLUFFY_KITTENS as a header guard (provided it was not defined anywhere else), but that would be a tricky bug if you defined it somewhere else, say as the number of kittens for something or other. In the header file add.h the declarations … Read more
It’s a preprocessor macro. All of it is preprocessor syntax, that basically says, if this macro has not already been defined, define it and include all code between the #ifndef and #endif What it accomplishes is preventing the inclusion of file more than once, which can lead to problems in your code. Your question: And … Read more
The preprocessor is a program that takes your program, makes some changes (for example include files (#include), macro expansion (#define), and basically everything that starts with #) and gives the “clean” result to the compiler. The preprocessor works like this when it sees #include: When you write: #include “some_file” The contents of some_file almost literally … Read more
#pragma once does have one drawback (other than being non-standard) and that is if you have the same file in different locations (we have this because our build system copies files around) then the compiler will think these are different files.
Add this to the page that you want to only be included <?php if(!defined(‘MyConst’)) { die(‘Direct access not permitted’); } ?> then on the pages that include it add <?php define(‘MyConst’, TRUE); ?>
FIRST QUESTION: Why aren’t include guards protecting my header files from mutual, recursive inclusion? They are. What they are not helping with is dependencies between the definitions of data structures in mutually-including headers. To see what this means, let’s start with a basic scenario and see why include guards do help with mutual inclusions. Suppose … Read more