Version imprimable
Bonjour,
Est-ce que quelqu'un connait un bon tuto ou autre sur comment intégrer une bibliothèque tiers dans un prog en c++.
Exemple un .dll, un .so, des sources ou autres.
Je ne comprends pas toutes les subtilités de l'include et du linker.
J'ai fait du java et en java c'est simple suffit de faire appel à la class contenue dans le jar qui va bien et de le rajouter dans le manifest et pouf pouf ca marche!
Comment faire ca simplement avec du c++??
Merci!
Salut,
Pour t'aider à comprendre, il faut déjà commencer par t'expliquer ce qui se passe lors de la compilation...
Elle se fait, en réalité, en trois étapes:
- passage du préprocesseur : le compilateur effectue certaines macro qu'il connait dans le code
- la compilation proprement dite: le compilateur transforme ton code en un code compréhensible par la machine, en créant des "fichiers objets"
- l'édition de lien : un outil (l'éditeur de liens :D) transforme tous les fichiers objets en un seul "gros" exécutable, et veille à ce que les appels aux différentes fonctions pointent au bon endroit.
(autant le dire tout de suite, ce n'est pas tout à fait complet, et très "shématisé", mais le but est juste de te permettre d'apréhender le principe ;))
Maintenant, entrons dans le vif du sujet...
Il faut déjà savoir que le compilateur est comme toi quand tu lis un livre: il lit le code d'en haut vers le bas, et ne sait a priori pas ce qui se passe dans les lignes qui suivent:
Arrivé à la ligne 10, il ne connait que ce qu'il a rencontré dans les lignes précédentes, et ne sait absolument pas ce qui se passe à la ligne 20 ;)
C'est la raison pour laquelle on crée des "fichiers d'en-tête" dont le seul but est de dire au compilateur
lorsque le préprocesseur rencontre une directive qui commence par #include, il va, tout simplement, copier le fichier dont le nom suit la directive, exactement à la place de la directive.Citation:
Tu vas sans doute rencontrer telle structure ou telle fonction... hé bien, sache déjà qu'elle existe
De cette manière, quand le compilateur va parcourir le fichier "modifié" pour le compiler, il trouvera toutes les déclarations qui apparaissaient dans le fichier d'en-tête à l'origine (et toutes les déclarations qui se trouvaient dans les fichiers qui ont été inclus dans le fichier d'en-tête).
Il saura donc que ces structures et que ces fonctions existent.
Il faut savoir que le préprocesseur va chercher dans certains dossiers après les fichiers d'en-tête et qu'il réagit différemment selon que le nom est entouré de <> ou de "" (mais bon, ici, on va la faire simple et passer sur l'explication ;)).
Sache qu'il commencera par chercher dans le dossier dans lequel se trouve le fichier d'implémentation (celui qui contient le code que tu as écrit), et qu'il faut donc éventuellement indiquer d'autres chemins que ceux qu'il connait si tes fichiers d'en-têtes se "baladent" à des places différentes.
Ton EDI devrait te permettre de gérer les dossiers dans lesquels aller chercher les fichiers d'en-tête, et, sinon, tu peux généralement indiquer d'autres dossiers, quant tu compile en ligne de commande, en ajoutant un parametre
-Ichemin/vers/dossier(c'est un i majuscule ;))
Une fois que le compilateur a fini son travail sur tous les fichiers d'implémentations, il passe la main à l'éditeur de liens
Lui aussi, il connait certains dossiers dans lesquels il va aller voir si les bibliothèques demandées se trouve, et, encore une fois, ton EDI te permet sans doute de préciser d'autres dossiers "exotiques".
Tu peux généralement indiquer un nouveau dossier dans lequel aller chercher les bibliothèque en ligne de commande en ajoutant le paramètre -Lchemin/vers/autre/dossier(c'est un "L" majuscule :D)
Cependant, l'éditeur de liens ne va, par défaut, utiliser qu'un nombre très limité de bibliothèque...
Il faut donc lui indiquer quelle bibliothèque il doit ajouter.
Généralement, les bibliothèque ont des noms particuliers tels que
libMaBibliotheque.a ou encore MaBibliotheque.lib (voir d'autres possibilités, selon le compilateur utilisé).
Le plus souvent, il suffit d'ajouter le paramètre -lMabibliotheque sans le lib et sans extension (mais bon, l'aide de ton compilateur t'indiquera surement comment il veut voir apparaitre ces informations ;)... (il s'agit d'un L minuscule)
Et il faut bien sur que le fichier lib ou .a se trouve dans un des dossiers dans lequel l'éditeur de lien va aller chercher ;)
Par la suite, si tu utilise des bibliothèques "partagées" ( des "dll" sous windows, de "shared_library" sous linux), il faudra juste veiller à ce que la dite bibliothèque soit dans un dossier connu du système:
- le dossier dans lequel se trouve l'exécutable
- n'importe quel dossier connu comme contenant les bibliothèques partagées
Voilà, en gros (car il y a quelques détails et quelques imprécisions dans mon écrit) ce qu'il faut savoir sur la liaison des bibliothèques externes ;)
Merci pour ces explications!! :king:
Si j'ai bien compris à la compilation faut lui mettre soit :
-I un dossier (i majuscule :) ) utilisé par le compilateur.
-L un dossier (L majuscule) utilisé par le linkeur.
ou -l le nom de la librairie (L minuscule) spécifications des librairies pour le linkeur.
Vu que t'es bien partie je permets une autre question. ;)
C'est quoi le différence entre le linkeur et le compilateur? Quels dossiers faut mettre au compilateur et lesquels au linkeur?
---------------Edit---------------------
Si j'ai une répertoire avec des sources que je veux utiliser je vais mettre
Sachant que monrep est dans le répertoire de mon projet.Code:
2
3
4
si je compile je dois spécifier monrep en paramètre -I ou -L??Citation:
/
monrep
|---monfichier.h
main.cpp
Code:gcc -o main main.cpp -Imonrep
tu dois passer un (des) parametre(s)
- -L pour indiquer un dossier à l'éditeur de liens dans lequel doit aller chercher les bibliothèque
- -l pour indiquer à l'éditeur de liens d'utiliser la bibliothèque
- -I pour indiquer au compilateur un dossier dans lequel doit aller chercher s'il y trouve les fichiers d'en-tête
- -i pour indiquer (éventuellement) au compilateur un fichier à inclure qui n'apparait pas dans le code
- -D pour indiquer au compilateur des définitions n'apparaissant pas dans le code (équivalent au #define)
Si le fichier d'en-tête est dans le même dossier que le fichier qui l'inclu, tu ne dois préciser ni -I, ni -i ni -L dans la commande de compilation...
Tout ce qui est utile est donné par la directive d'inclusion
La compilation s'effectue avec la simple commandeCode:#include "monfichier.h" //remarque: pas de chemin ;)
si tu indique un chemin à suivre pour l'inclusion de fichier, sous une forme proche deCode:gcc -o main main.cpp
il n'y a rien à préciser non plus.Code:
2
Si, par contre (et c'est souvent le cas pour les bibliothèques extèrnes) les fichier d'en-tête se trouve dans un dossier "exotique" (AKA trop loin pour t'amuser à écrire le chemin relatif dans le code), il suffira d'un parametre -I
Code:gcc -o main main.cpp -L/dosser/ou/se/trouve/lesHdeLaLib
Nickel, merci pour toutes ces explications c'est beaucoup plus claire maintenant. :king:
t'as dis parametre -I et tu mets -L??Citation:
parametre -I
Code :
gcc -o main main.cpp -L/dosser/ou/se/trouve/lesHdeLaLib
D'après ce que j'ai compris faut bien mettre -I
Pour indiquer au compilateur d'aller chercher les fichiers d'en-tête.Code:gcc -o main main.cpp -I/dosser/ou/se/trouve/lesHdeLaLib
J'ai bon??
-L c'est pour les bibliothèques, -I pour les fichiers d'en-tête.
Un exemple plus précis en décomposant:
compilation:
édition de liens:Code:
2
Code:gcc -o prog main.o autre.o -L/dossier/ou/se/trouvent/les/libs
Je voulais juste faire remarquer qu'il y' avait une erreur, que j'étais attentif à son explication et que j'ai bien compris.
Merci pour l'exemple en plus.