5

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 know where is the implementation of the class member function declared in the header files?

Say I want to write some program which takes advantage of the OpenCV library. Normally I would want to use:

#include <opencv2/core/core.hpp>
#include <opencv2/imgproc/imgproc.hpp>
#include <opencv2/highgui/highgui.hpp>

However, these are just header files which, as far as I can tell, only declares functions but without implementation. Then how does the compiler know where to find the implementation? Especially when I want to build a .so file.

There is a similar post. Basically it said thrid-party library, esp. commercial product don't release source code, so they ship the lib file with the header. However, it didn't make clear how does the compiler know where to find the lib file. In addition, The answer in that post mentioned if I want to compile the code of my own, I would need the source code of the implementation of those header files. Does that mean I cannot build a .so file without the source of the implementation?

Community
  • 1
  • 1
Charlie Lam
  • 111
  • 7
  • 4
    Possible duplicate of https://gcc.gnu.org/onlinedocs/cpp/Search-Path.html – Lightness Races in Orbit Dec 29 '16 at 14:30
  • 3
    These are implemented in libraries. ***Then how does the compiler know where to find the implementation?*** You usually need to inform the linker which libraries to link. – drescherjm Dec 29 '16 at 14:31
  • 3
    *"how do the compiler know where is the implementation of the class member function declared in the header files?"* - it doesn't. The header contains everything the compiler needs so it doesn't need to have access to the actual implementation. Only the **linker** needs the actual (compiled) implementations. – Galik Dec 29 '16 at 14:34
  • 1
    Possible duplicate of [C/C++ header and implementation files: How do they work?](http://stackoverflow.com/q/9224537/3425536) – Emil Laine Dec 29 '16 at 15:30
  • @tuple_cat I am not sure if it is a duplicate. That post did answer my question to some extent, but I also asked how do deal with the situation when I don't know where the implementation file is, or when the implementation is an object/library file shipped with the header. – Charlie Lam Dec 30 '16 at 12:13

4 Answers4

8

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.

Community
  • 1
  • 1
Sourav Ghosh
  • 133,132
  • 16
  • 183
  • 261
0

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.

Isac Casapu
  • 1,163
  • 13
  • 21
0

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.

Gerhardh
  • 11,688
  • 4
  • 17
  • 39
-1

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.

Jean-Baptiste Yunès
  • 34,548
  • 4
  • 48
  • 69