取消定义已经包含的标题

Question

I want to check a header in my source file and if its already defined, I want to undefine it.

Is it possible?

Answer 1

'including' something in c/c++ essentially means: make the preprocessor copy and paste the #include <file> directly into your source code (or better: the preprocessed version of your source code).

you can not make that copy and paste action undone. you can however '#undef' stuff introduced by that copy and paste action, but you have to do this for every atom you dislike, you just can't #undef the whole file.

to check, if a given header was already included, you have check if something from that header file is defined already. most headers contain so called 'guards' which look like

 #ifndef FOO_H
 #define FOO_H
 /* lots of code */
 #endif

for a file called 'foo.h'. you could check for 'FOO_H' like this:

 #ifdef FOO_H
 /* do your magic */
 #endif

example:

 foo.h:
 #ifndef FOO_H
 #define FOO_H
 struct Foo { /* ... * };
 #endif

 bar.h:
 #include "foo.h"
 #ifdef FOO_H
 #undef Foo
 #endif

but that can lead to a lot of headaches if you are not aware of what exactly you are doing. IF your real problem is, that your compiler complaints about 'already declared stuff' then you are not guarding your header files against multiple inclusion...

Answer 2

Do you mean you want to ensure that the header file is included once and only once? The standard solution to this is using an include guard .

Ie surround the contents of your header with

#ifndef MY_HEADER // a unique identifier for each header
#define MY_HEADER

...

#endif

This is guaranteed to work in all platforms. Some compilers also provide a #pragma to achieve the same effect with less hassle, eg in Visual C++ you can add

#pragma once

at the start of your header file.

Answer 3

#undef is the opposite of #define and actually cancels it.

It's very useful when you need a macro for some task but does not wish to "pollute" the symbol tables

// referencing FOO is an error (not yet defined)

#define FOO(arg_) ....

FOO(A)
FOO(B)
FOO(C)

#undef FOO

// referencing FOO now is an error (not defined)

There is no way to cancel a #include directive.

Answer 4

You can't do what you seem to want to do. If you don't want the header included your choices are

don't include it in the first place

conditionally include it or not via the prepocessor eg

#ifdef INC_MY_HEADER
#include "myheader.h"
#endif

or assuming the header has header guards just define the header guard before the header is included eg from the commend line -DMY_HEADER or similar

If the real problem is that you have different headers defining things with the same name then you probably need to look into namespaces so you don't get clashes

Answer 5

You could stop the header being included - the simplest way would be to remove or comment out the #include directive.

You could also pre-define your guards so that the include is inneffective.

foo.h
#ifndef __FOO_H
#define __FOO_H

/* contents of foo.h */

#endif /* __FOO_H */


foo.cpp
#define __FOO_H
#include "foo.h"
/* contents of foo.cpp */

Using this strategy you could use the preprocessor to select whether to pre-define the guards, or even have inner guards within you header.

If you really need only to have part of the file included, it would be better to split the file into two.