Show
Click to see the query in the CodeQL repository A common pattern in header files is to use pre-processor directives to guard a header file against being processed more than once per translation unit. This practice is intended to prevent compilation errors. However, pre-processor include guards are prone to human error themselves because each include guard must be assigned a unique macro name to function correctly. If two header files share the same guard macro, the compiler may unexpectedly skip the second file it encounters, leading to compilation errors or configuration bugs. The query will flag the pre-processor Recommendation¶First decide whether the duplicate include guard is dangerous. A duplicate include guard may cause the header file to be skipped over when it shouldn’t be, but occasionally this design is used on purpose to ‘override’ an existing header file. To address the issue, rename the macros used by all but one instance of the duplicate include guard. Remember to change both the Example¶Here’s an example of two header files that have accidentally been given the same include guard macro. To fix the issue, rename both occurrences of the macro in the second file, for example to ANOTHER_HEADER_FILE_H. // header_file.h #ifndef HEADER_FILE_H #define HEADER_FILE_H // ... #endif // HEADER_FILE_H // another_header_file.h #ifndef HEADER_FILE_H // should be ANOTHER_HEADER_FILE_H #define HEADER_FILE_H // should be ANOTHER_HEADER_FILE_H // ... #endif // HEADER_FILE_H References¶
2.4 Once-Only HeadersIf a header file happens to be included twice, the compiler will process its contents twice. This is very likely to cause an error, e.g. when the compiler sees the same structure definition twice. Even if it does not, it will certainly waste time. The standard way to prevent this is to enclose the entire real contents of the file in a conditional, like this: /* File foo. */ #ifndef FILE_FOO_SEEN #define FILE_FOO_SEEN the entire file #endif /* !FILE_FOO_SEEN */ This construct is commonly known as a wrapper #ifndef. When the header is included again, the conditional will be false, because CPP optimizes even further. It remembers when a header file has a wrapper ‘#ifndef’. If a subsequent ‘#include’ specifies that header, and the macro in the ‘#ifndef’ is still defined, it does not bother to rescan the file at all. You can put comments outside the wrapper. They will not interfere with this optimization. The macro
ObjectiveTo prevent a C or C++ header file from being compiled more than once as part of any given compilation unit, regardless of how many times it is included by other files BackgroundWithin a C or C++ program there are some types of declaration that cannot be safely repeated within a given compilation unit. These include This can be problematic when header files include other header files, and doubly so when they are part of a library intended for use by other programmers. (A compilation unit typically consists of one source file, and all of the header files that are directly or indirectly included by that source file.) ScenarioSuppose that you are writing a library in C++ called The file MethodThe standard method for preventing a header file from being compiled more than once is to add an include guard. This consists of:
For example, using the include
guard macro name #ifndef LIBFOOBAR_BAZ
#define LIBFOOBAR_BAZ
class baz
{
// ...
};
#endif
The chosen macro name must be unique within the program in question. In the case of libraries the aim should be to make it globally unique, so that indepenently developed libraries can be used alongside each other without interference. To this end it is helpful to use a systematic naming convention for the include guard macros. Typically this would incorporate the name of the program or library, and the relative pathname of the header file in question (as in the example above). If you examine the system headers in
It is considered good practice to add include guards to all header files, whether or not they are technically needed. This avoids the need to determine which guards are necessary, eliminates the possibility of making a mistake, and ensures that the code is robust against future changes. Further Reading
Is a member function that is automatically called when a class object is?A destructor is a member function that is invoked automatically when the object goes out of scope or is explicitly destroyed by a call to delete . A destructor has the same name as the class, preceded by a tilde ( ~ ).
Which function is automatically called in C plus plus if we do not define it in the class?A constructor in C++ is a special method that is automatically called when an object of a class is created.
Which of the following is automatically called when an object is destroyed?A destructor is a member of a function which is automatically called when the class is destroyed.
Which operator can be used by an object to access members of the class?Accessing the members of the class (data and functions) is done using the dot (.) operator, which is also called as the member access operator. If obj is the name of the object and there is a function “display ()” in the class, then the function can be accessed as “obj. display ()”.
|
Which of the following is a directive used to prevent a header file from accidentally being included more than once?
Urheberrechte © © 2024 ketiadaan Inc.
