Discussion :

[Gourbish]

Salut à tous.

J'ai une petite question à vous poser, et un dessin plutôt que des phrases sera bien plus explicites.

A, B, et Z sont des petites librairies que j'ai créées.

A est une librairie qui utilise la librairie Z.
B est une librairie qui utilise la librairie Z.

Le programme final a besoin des deux librairies A et B.

Lors de la compilation j'ai une floppée de warnings qui m'expliquent que la librairie Z est définie 2 fois et que la seconde fois est ignorée (warning LNK4006 dans Visual Studio). Le programme fonctionne, mais il y a un warning pour chaque fonction présente dans Z.

Je voudrais donc savoir comment éviter tous ces warnings (sans les ignorer) pour avoir un programme plus propre. Je suppose qu'il y a quelque chose d'un peu brutal dans mon prog ou mes libs pour avoir tous ces warnings.

Merci d'avance.

Gourbish.

PS : on ne prend jamais le temps, mais... FELICITATIONS ET MERCI aux auteurs du site ainsi qu'à ceux qui l'enrichissent jour après jour, heure après heure que cela soit sur le forum ou sur les tutos ou autres. Longue vie à Developpez.com !!!

[Mac LAK]

A priori, tes librairies A, B et Z sont des librairies statiques. Dans un tel cas de figure, ce n'est JAMAIS la librairie A qui doit linker la librairie Z, mais le PROGRAMME utilisant la librairie A qui doit savoir que la librairie Z est également à inclure dans le link.

Côté Visual, cela veut dire qu'il te faut décocher la librairie Z dans les dépendances des librairies A et B, et l'ajouter à ton programme principal.


Ce cas arrive fréquemment si tu as inclus ta librairie Z via un #pragma comment(lib,"....") non protégé, dans les entêtes publics des librairies A et B.

[Gourbish]

Oui en effet ce sont des librairies statiques, j'avais oublié de préciser.
Mais si la librairie A a besoin de Z pour fonctionner, il faut bien qu'elle soit dans ses dépendances. Si A a besoin de certaines fonctions de Z, alors A va dépendre de Z. Je ne me trompes pas jusque là. Donc pourquoi m'expliques-tu que A ne doit JAMAIS linker Z ?

Sinon, pour ce qui est du "#pragma comment(lib,"....")", je n'ai rien de cela. Pour utiliser une librairie, j'ajoute le .lib dans les dépendances du projet, j'inclus le .h nécessaire dans le code, et roule ma poule. J'ai appris comme cela par moi même donc je ne sais pas trop à quoi correspond le #pragma comment(lib,"...."), et encore moins comment le protéger.

[Mac LAK]

Mais si la librairie A a besoin de Z pour fonctionner, il faut bien qu'elle soit dans ses dépendances.

Non, pas en statique. Tu as besoin bien entendu des chemins #include de Z dans ton projet A, mais pas du .LIB.

Si A a besoin de certaines fonctions de Z, alors A va dépendre de Z. Je ne me trompes pas jusque là. Donc pourquoi m'expliques-tu que A ne doit JAMAIS linker Z ?

Parce qu'il n'y a AUCUNE édition de lien avec une librairie statique... Tu peux vérifier dans tes options de projet A, B et Z, d'ailleurs : la section n'existe pas !

Sinon, pour ce qui est du "#pragma comment(lib,"....")", je n'ai rien de cela. Pour utiliser une librairie, j'ajoute le .lib dans les dépendances du projet, j'inclus le .h nécessaire dans le code, et roule ma poule. J'ai appris comme cela par moi même donc je ne sais pas trop à quoi correspond le #pragma comment(lib,"...."), et encore moins comment le protéger.

C'est pour ça que tu as un doublon sur Z : le rajout du .LIB dans le projet A ET dans le projet B rajoutes deux fois la librairie, tout simplement. Ce que tu fais ne serait valable que dans le cas de DLL (qui ont une phase d'édition de liens), et bien sûr d'exécutables (pareil).

Le #pragma permet d'indiquer à Visual qu'il doit linker le .LIB "tartempion" dès l'inclusion d'un header particulier. Cela évite d'avoir à rajouter manuellement le nom de la librairie dans les settings du projet, ou d'ajouter directement le fichier dans l'arborescence de fichiers du projet. C'est ce que l'on appelle un link automatique, c'est beaucoup utilisé pour les entêtes standards de Windows par exemple.
On protège ça en mettant le #pragma dans l'entête "racine" de la librairie (=celui utilisé par tout le monde, typiquement celui qui définit les déclarations d'importation/exportation pour une DLL par exemple). L'entête doit bien entendu être protégé contre les inclusions multiples (#ifdef / #define / #endif), et il est souhaitable d'ajouter un #pragma once juste avant le #pragma d'inclusion pour éviter par toutes les manières possibles un double lien du .LIB.

[Gourbish]

Bien bien bien tout ça...
Merci pour toutes ces explications.

Le soucis est donc résolu en suivant tes instructions, et je me coucherai moins couillon ce soir ! :-)


Pour le moment, j'ai donc résolu ça ainsi :
A dépend de Z.
Donc A contient des #include provenant de Z, et c'est tout.

Le prog final, lui, dépendant de A, va contenir :
- des fonctions provenant de A => dans ses dépendances, j'ai mis A.lib
- des fonctions provenant de Z => dans ses dépendances, j'ai mis Z.lib
Tout ceci étant fait dans les réglages du projet visual.
Cela fonctionne impec'.


Maintenant, dis moi si je me trompes, si je désire utiliser les #pragma :
- soit je fais des #pragma pour A et pour Z dans mon prog
- soit je fais un #pragma pour A dans prog et un #pragma pour Z dans la lib A

C'est cela ? Ainsi, le 2ème cas permettrait d'éviter de savoir qu'il existe une lib Z qu'il faut linker lorsque l'on linke déjà A.

[Mac LAK]

Maintenant, dis moi si je me trompes, si je désire utiliser les #pragma :
- soit je fais des #pragma pour A et pour Z dans mon prog
- soit je fais un #pragma pour A dans prog et un #pragma pour Z dans la lib A

C'est cela ? Ainsi, le 2ème cas permettrait d'éviter de savoir qu'il existe une lib Z qu'il faut linker lorsque l'on linke déjà A.

C'est bien cela, sauf qu'en général, chaque librairie définit son propre link.

Donc, dans un entête incontournable de la librairie Z, tu vas ajouter un #pragma comment(lib,"libZ") (tu noteras l'absence de l'extension .lib), précédé d'un #pragma once par sécurité.
S'il est possible d'inclure plusieurs entêtes de Z de façon indépendante (ex : librairie de plusieurs modules totalement indépendants), alors il te faudra ajouter le #pragma dans chaque entête "racine".

Tu fais ensuite la même chose pour la librairie A : ses entêtes indiquent le #pragma pour elle-même. Tu ne t'occupes pas de la librairie Z, sauf si elle n'est pas de toi bien sûr et que tu veux, justement, régler une dépendance manquante.
Dans ce dernier cas, les entêtes de A vont également inclure la librairie Z, de façon à rendre l'intégralité du processus de link automatique. C'est ce qu'il faut utiliser par exemple lorsque tu encapsules une librairie tierce.

Enfin, dans le programme principal, tu ne t'occupes de rien d'autre que de renseigner, éventuellement, les chemins d'accès aux librairies. Tu n'as pas à te préoccuper du nom de la librairie, juste du répertoire où elle est stockée, exactement comme un fichier d'inclusion.

Tu peux également linker automatiquement les versions Debug et Release, avec un code de ce genre :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
#pragma once
#pragma message("Autolink : MyLib")
#ifndef _DEBUG
	#pragma comment(lib,"mylib")
	#pragma message("------> Release.")
#else
	#pragma comment(lib,"mylib_d")
	#pragma message("------> Debug.")
#endif

Amuses-toi bien, il y a des choses très intéressantes à faire avec les directives #pragma.