getting #includes right
There are two types of #include statements: #include \<foo.h\> and #include "foo.h".
Say we have the file header1.h in /usr/include/mylib/ that contains the following:
- include <header2.h>
- include "header3.h"
The preprocessor will search for the file header2.h in all the paths given as -I arguments and then replace the line with the contents of that file.
For line 2 the preprocessor tries to use the file /usr/include/mylib/header3.h first and if it does not exist search for the file like for header2.h. The important part to note here is that the preprocessor does not look in the directory of the source file that includes header1.h but in the directory where header1.h resides.
Now, which include statement is the one to use? After all you can specify every directory you want using -I and thus could use #include \<...\> everywhere.
as an application developer
- Include headers from external libraries using angle brackets; examples:
- include <iostream>
- include <QtCore/QDate>
- include <zlib.h>
- Include headers from your own project using double quotes. Using angle brackets works correctly if the first -I switch to the compiler is your own source directory. Ideally you would not need to specify -I./ though, as that might break with library headers that have the same filename as a header of your project (i.e.: If a library has the header file foo.h and your project has a different file with the same filename the compiler will always pick the header from your project instead of the one from the library because the source directory of the project is specified first.)
as a library developer
- Include headers from external libraries using angle brackets (see above for examples)
- Include headers of your own library and libraries that belong to it using double quotes. If you use subdirectories for the installed header files you need to have the exact same directory structure for the headers in the source directory. Example:
/usr/include/libfoo/ contains the directory bar. In the libfoo directory is the header header1.h. In the bar subdirectory is the file header2.h. The latter depends on the former so it includes it using
- include "../header1.h"
If the source directory structure of the library is not the same (in this case: header2.h in a subdirectory of the directory where header1.h resides) this obviously will break.
It is also possible to use angle brackets in library headers, but that requires the application to supply the exactly correct -I paths (e.g. libfoo above can be used either with -I/usr/include and #include \<libfoo/header1.h\> or -I/usr/include/libfoo and #include \<header1.h\>, if libfoo were to use angle brackets to include its own headers one of the include switches has to be present for the lib to find its own headers). Also angle brackets require the application to not put any include directory before the -I switch for the lib that contains header files of the same filename as for the library. An example how angle brackets can break the build:
/usr/include/libxyz/xyz.h includes foo.h using angle brackets and expects to have it replaced with the contents of the file /usr/include/libzyx/foo.h. Assuming there's another library that also ships a foo.h file in the directory /usr/include/anotherlib. If the application that uses both libraries compiles with g++ -I/usr/include/libxyz -I/usr/include/anotherlib ... libxyz will work as expected (but anotherlib might break). If the application compiles with g++ -I/usr/include/anotherlib -I/usr/include/libxyz ... the header xyz.h will include the file /usr/include/anotherlib/foo.h instead of the file that is shipped with libxyz. The same problem can appear if an application has a header file of the same name as a library and specifies -I./ as the first include directory.