How can I avoid explicitly declaring directory paths in C or C++ #include directives?

Question

Hi,

I am making a simulator and have written lots of files and headers. The problem is whenever I include a file I give the relative path of the particular file. For example a typical code in my application would begin like

#ifndef AI_H
#define AI_H

#include <cstdlib>

#include "../world/world.h"
#include "pathPlan.h"
#include "skills/tryskill.h"
#include "../info/condition.h"
#include "dataStructures/destination.h"
#include "../params/gamePlay.h"
#include "../modules/controlModule.h"


class ai
{
    public:

etc etc

I want to avoid using the relative paths. For example I want to directly include "tryskill.h" and "destination.h" without giving the absolute paths. That way I wont need to bother if I change the location of any particular file. I am using Ubuntu 9.10. Any help would be highly appreciated.

Answer 1

Any good IDE or makefile will allow you to list relative search paths for files. Look into this for your solution.

Answer 2

Typically, if you're compiling from the command line, you would supply include search paths to your compiler (gcc example: http://gcc.gnu.org/onlinedocs/cpp/Search-Path.html). If you're using an IDE, you should be able to specify include search paths to your IDE and your IDE will pass these on to your compiler.

Answer 3

Really it all depends on your include path, different compilers might call it different things but in gcc

-Idir  Append directory dir to the list of directories searched for include files.

So in your example you would specify ../world etc... in the list of directories in -I

Answer 4

Compilers will let you specify on the command line (or a response/configuration file) the directories to search for header files. You can generally configure this in a makefile or IDE's project settings if you're driving a build using one of those tools.

However, in general, I prefer to specify the relative path for headers that 'belong' to a project (as opposed to maybe libraries that are used across projects). That way when you add a new module, you don't have to muck around with project settings or make files to get things to continue to build.

That's if you like to keep the header for a module along-side the module's implementation instead of having the headers piled into a single (or small set of) directories. Either organization is arguably as good as the other.

Answer 5

You should be using paths that are relative to your program's/library's top-level include path. There are many different ways to do this, depending on how you are building your program. If you are using the CMake build system -- which I strongly urge you to use -- then you would use the INCLUDE_DIRECTORIES command:

INCLUDE_DIRECTORIES(include)

If your "info/condition.h" file is located in "include/blah/info/condition.h", then you would include it with:

#include <blah/info/condition.h>

If you are compiling from the commandline with g++, you can use the -I commandline switch:

g++ file1.cpp file2.cpp ... fileN.cpp -I./include

If you are using Make, you can ensure that this is flag is used by adding the following line:

CPPFLAGS += -I./include

Another possibility, though one I do not recommend, is to define the environment variable CPATH:

# Note the following is what you would do in BASH:
export CPATH="$CPATH":"`pwd`/include"

Answer 6

Food for thoughts: what is the alternative ?

#include "pathPlan.h"
#include "exception.h"
#include "world.h"
#include "exception.h" // uh ?

I've always been wary of having too many paths declared in the include paths variable, the issue is that the more paths there are the more likely you are to get a filename clash, and it's annoying to debug, really.

I much prefer using this:

// 3rd party libraries
#include <3rdParty1/foo.h>
#include <3rdParty2/foo.h>

// Projects I depend on
#include "myProject1/bar.h"

// Current project, from the include directory
#include "currentProject/foobar.h"
#include "currentProject/another.h"

// Current project, from the source directory (private includes)
#include "../world.h"
#include "../detail/helper.h"

Which means for a given project "thingy" I have the following file:

// in thingy/1-3-0-2/include/thingy/foo.h

namespace thingy  // base namespace is project name
                  // namespace hierarchy identical to folders hierarchy
{
}

And then I have the following on my compilation line:

-I${Repository}/thingy/1-3-0-2/include

Sure it's a bit more typing, but it helps keeping things all tidy:

• namespace / folder correlation makes it easier to find the location of the file
• projects prefixing makes it impossible for 2 files from different projects to be mixed up even when they have the same name