Where is the implementation of included C++/C header files?

Question

This may seem a little stupid:) But it\'s been bothering a while. When I include some header files which are written by others in my C++/C program, how does the compiler kno

Answer 1

The exact answer is platform specific, but in general I'd say that some libraries are in fact header-only, and others include the implementation of the library's methods in binary object files. I believe OpenCV belongs to the second kind, i.e. provides the implementation in object files, for either dynamic or static linking, and your program links against them. If your build works, then it is already configured to link against those libraries. At this point the details become very much platform and build-system specific.

Note that for common platforms like Windows, Mac and Linux you seldom need to build popular libraries like OpenCV yourself. You mentioned .so files, which implies dynamic linking on Linux. This library is open-source so in theory you could build it yourself, but in practice I'd much rather use my distribution's package installation tool (e.g. apt-get or yum) to install opencv-dev (or something similar) from my distribution's repository.

Answer 2

In general, the implementation is distributed as form of pre-compiled libraries. You need to tell the compiler where they are located.

For example, for gcc, quoting the online manual

-llibrary
-l library

Search the library named library when linking. [...]

and,

-Ldir

Add directory dir to the list of directories to be searched for -l.

---

Note: you don't need to explicitly specify the standard libraries, they are automatically linked. Rather, if you don't want them to be linked with you binary, you need to inform the compiler by passing the -nostdlib option.

Answer 3

As the others already explained, you need to tell your compiler where to look for the files. This implies that you should know which path to specify for your compiler.

Some components provide a mechanism where you don't need to know the exact path but can automatically retrieve it from your system.

For example if you want to compile using GTK+3 you need to specify these flags for your compiler:

CFLAGS:= -I./ `pkg-config --cflags gtk+-3.0`

LIBS:= -lm `pkg-config --libs gtk+-3.0`

This will automatically result in the required include and library path flags for GCC.

Answer 4

The compiler toolchain contains at least two major tools: the compiler and the link editor (it is very common to name compiler the whole chain, but strictly speaking it is wrong).

The compiler is in charge of producing object code from the available source code. In that phase the compiler knows where to locate standard headers, and can be told to use non-standard dirs to locate headers. For example, gcc uses -I to let you specify some more alternate dirs that may contains headers.

The link editor is in charge of producing executable files (its basic common usage) from object codes. To produce an executable it needs to find every implementation of declared things at compile-time for which you didn't provide source code. These can be other object codes, object codes in libraries, etc. The link editor knows where are located standard libraries and can be told to let you specify non-standard dirs. For example you can tell the gcc toolchain to use alternate dirs with L that may contain libraries. You may be aware that link edition is now usually a two phase process: location-and-name-resolution at link-time and real link-edition at run-time (dynamic libraries are very common).

Basically a library is just a collection of object code. Consult internet to see how you can easily build libraries either from source code of from object code.