Logo Questions Linux Laravel Mysql Ubuntu Git Menu
 

C++ : Difference between linking library and adding include directories

Pretty much title sums it up.

I'm not sure the difference between the two if i'd like to use a library.

Thanks!

like image 670
Setheron Avatar asked Aug 17 '11 16:08

Setheron


People also ask

What's the difference between include and include<>?

The difference between the two types is in the location where the preprocessor searches for the file to be included in the code. #include<> is for pre-defined header files. If the header file is predefined then simply write the header file name in angular brackets.

What is the difference between the following two# include directives# include filename# include?

The difference is in the location where the preprocessor searches for the included file. For #include "filename" the preprocessor searches in the same directory as the file containing the directive. This method is normally used to include programmer-defined header files.

What are include directories?

The Include Directories corresponds to the environment variable INCLUDE . Directory settings displayed in the window are the directories that Visual Studio will search for include files referred to in your source code files. Corresponds to environment variable INCLUDE.

What is the difference between library and header files in C?

Header File is the file where all the headers name are mentioned that going to be used or consumed in the main code file. On other hand Library is the file where the implementation code of each header is written down which is mentioned in the Header file.


2 Answers

In general, you need both.

Include files contain declarations of types, prototypes of functions, inline functions, #defines, ..., in general every information about the library the compiler needs to be aware of when compiling your files.

Static libraries, instead, contain the actual object code of the functions of the library. If the headers contain the prototypes, the static libraries contain the (compiled) definitions of the functions, i.e. the object modules that the linker will link with yours.

If you only included the header file without linking against the static library, the linker would complain about missing definitions, because you would be using functions declared in the header, but not defined anywhere (i.e. with no implementation). On the other hand, if you only linked the static library without providing the header, the compiler would complain about unknown identifiers, since it wouldn't have a clue about the library symbols you're using.

The concept is very similar to when you compile a multi-file project: to access the definitions written in other .cpp you need to include just a header with their declarations, and the linker in the end links together the various object modules.

As far as dlls are concerned, usually an import library is provided; import libraries are like static libraries, but, instead of containing all the code of the library, they contain small stubs that call the functions into the dll. Every time a call to a library function is encountered in one of your object modules, the linker directs it to the stub, which in turn redirects it to the code into the dll1. All in all, when dealing with dlls on Windows you usually have a .h (prototypes/...), a .lib (import library you link against, contains the stubs) and a .dll (dynamic-linking library containing the actual code of the library).

By the way, some libraries are "header only" (you can find many in boost), which means that all their code is put into a header, so no static library is needed. Such libraries are often just made of inline code (functions/classes/...) and templates, for which no separate definition is needed.

Often this is done because static libraries are ugly beasts for several reasons:

  • you have to explicitly link against them;
  • since they are linked directly to your code, they have to use exactly your same C/C++ runtime library, which means that, at least on Windows, it's impractical to distribute static libraries (different compilers, different compiler versions, different configurations of the same compiler use different standard libraries, distributing a static library for every combination of these aspects would be impractical at least);
  • because of this, in general you have to first compile on your own version of the static library, and only then link against it.

Compare all this with just including a header file... :)


  1. Actually, modern toolchains can recognize these stubs and avoid the extra indirection step. See this series by Raymond Chen for details.
like image 118
Matteo Italia Avatar answered Sep 28 '22 17:09

Matteo Italia


The compiler needs to know the include directories, since it needs to include header (interface) files of libraries you want to use.

The linker needs to know the library directories, since it needs to link your executable to the (precompiled) implementation of the library.

See also What are the differences between a compiler and a linker?

like image 22
Ferdinand Beyer Avatar answered Sep 28 '22 18:09

Ferdinand Beyer