有没有办法告诉g ++编译器，而不是在某个-I路径中寻找include标头？

Question

I'm trying to compile a cpp file that uses include headers from 2 folder locations. Both the folders has lot of headers that are necessary for my file.

Now, one of the header file is present in both the folders, but the problem is they are of different version. Hence the functions in that common header have same name but different API signature.

Something like this:

Folder A:

• foo.hpp
• bar1.hpp
• bar2.hpp
• bar3.hpp

Folder B:

• foo.hpp
• bar4.hpp
• bar5.hpp
• bar6.hpp

API of function foobar from foo.hpp of folder A: void foobar(arg1, arg2);

API of function foobar from foo.hpp of folder B: void foobar(arg1, arg2, arg3);

#include "foo.hpp"
#include "bar1.hpp"
...
#include "bar4.hpp"
...
...

int main(){
...
foobar (arg1, arg2);
...
}

g++ main.cpp -o MyExe -I< path-to-folder-A > -I< path-to-folder-B >

This throws the errors like multiple redefinition of function , no matching function call etc., for various functions in the header.

So, my question is: Are there any flags to tell the compiler only to consider the definition found from folder A and ignore the one from folder B?

Note on code limitations : I cannot alter the folders or files of A and B in any manner. Neither can I give absolute paths to the headers instead of -I.

Answer 1

Assuming that you can give more elaborate relative paths:

If folder b is a subfolder of main.cpp's, you can just use

#include "<relative-path-to-folder-b>/foo.hpp"

If folder b isn't a subfolder and you can add another -I directive, then add another -I directive:

g++ main.cpp -o MyExe -I<path-to-folder-before-b> -I< path-to-folder-A > -I< path-to-folder-B >

and then add the include

#include "b/foo.hpp"

Answer 2

One (very brittle, hack-ish and possibly slow-to-compile) way of solving this relies on the manual include guards ( #ifndef MY_HEADER etc.) that are presumably present in the headers in question:

1. Gather all the header files that you want to use (excluding all the ones you don't want/need).

2. Create a central include file that #include s all of these files (by as absolute of a path as you can, ie make sure this picks the correct foo.hpp gathered above, not one of the "original" ones).

3. Tell your compiler to force-include this central include file. Realistically, you should just make this a precompiled header (or include it in yours).

4. Due to force-including all these headers at the start of every translation unit, all the include guard defines are already set before you ever reach the point of the "wrong" headers being included. The compiler will still copy-paste them in there, but the include guards will prevent any code in them from being considered.