Commande du préprocesseur #define et fichiers headers ! [C] - C++ - Programmation
Marsh Posté le 06-09-2002 à 21:44:51
Le compilateur, il s'en fout.
C'est le linker qui par contre a besoin de trouver les symboles déclarés dans les .h
Marsh Posté le 06-09-2002 à 21:59:57
si tu veux mon avis si ton compilo cherche ou dans tata.lib ou dans toto.lib lorsque tu inclues stdlib.h ben ... change de compilo
Marsh Posté le 06-09-2002 à 22:24:44
Le code des fonctions décrites est déjà compilé
les headers indiquent juste les fonctions qui existent et où les trouver ainsi que les structures des données pour que le linker puissent les lier à l'exe
(C un peu le même system que lorsqu'on fait appel à des DLL)
Si G rien compris faite moi signe
Marsh Posté le 06-09-2002 à 22:35:13
[SDF]Poire a écrit a écrit : Le code des fonctions décrites est déjà compilé les headers indiquent juste les fonctions qui existent et où les trouver ainsi que les structures des données pour que le linker puissent les lier à l'exe (C un peu le même system que lorsqu'on fait appel à des DLL) Si G rien compris faite moi signe |
Salut,
Oui tu as bien compris, merci.
Je développe une librairie qui contient plusieurs fichiers *.c, chacun contenant quelques fonctions.
Comment dois-je faire pour inclure ces fichiers dans une application ?
Dois-je créer un fichier header pour chaque fichier de la librairie, et si oui, que dois-je inclure dans les fichiers header ou les fichiers *.c pour les 'lier' ?
Sinon, quelle méthode me proposes-tu ?
Merci.
Marsh Posté le 06-09-2002 à 22:35:38
Oui c'est ça, les .h ne contiennent que des prototypes, qui ne servent qu'à vérifier que l'utilisation de la fonction en C n'est pas incorrecte. En fait, on peut même les omettre et faire des déclarations implicites (GROUIIIIIIIIIIIIIIIIIIIIKKKKKKK).
C'est au moment de l'édition des liens que le linker va chercher les fonctions correspondantes. Par défaut, il va au moins farfouiller dans la libc, mais on peut lui préciser des bibliothèques en plus, en lui donnant le chemin : /usr/lib/libtoto.a pour la version statique, /usr/lib/libtoto.so pour la version dynamique, ou tout simplement comme on fait habituellement, -ltoto.
Marsh Posté le 06-09-2002 à 22:41:24
juju-le-barbare a écrit a écrit : Salut, Oui tu as bien compris, merci. Je développe une librairie qui contient plusieurs fichiers *.c, chacun contenant quelques fonctions. Comment dois-je faire pour inclure ces fichiers dans une application ? Dois-je créer un fichier header pour chaque fichier de la librairie, et si oui, que dois-je inclure dans les fichiers header ou les fichiers *.c pour les 'lier' ? Sinon, quelle méthode me proposes-tu ? Merci. |
Ds les headers tu peux mettre directos le code de tes fonctions si tu veux (par exemple celles que tu utilises souvent)
aprés tu inclus ton header et ça marche
Si tu veux faire une bibliothéque C + compliqué
il fo que tu fasses ta bibliotheque (on pourra y acceder directement comme l'a dit Jar Jar)
Mais tu peux faire un header avec les types de données utilisés et les appels
GCC à des options pour lier les bibliothéques regarde la doc
désolé de ne pas pouvoir t'aider + mais tout ça n'est + trés rescent ds mon esprit
Marsh Posté le 06-09-2002 à 22:41:38
juju-le-barbare a écrit a écrit : Je développe une librairie qui contient plusieurs fichiers *.c, chacun contenant quelques fonctions. Comment dois-je faire pour inclure ces fichiers dans une application ? Dois-je créer un fichier header pour chaque fichier de la librairie, et si oui, que dois-je inclure dans les fichiers header ou les fichiers *.c pour les 'lier' ? Sinon, quelle méthode me proposes-tu ? |
Pour faire les .h, en gros tu reprends les déclarations de toutes tes fonctions, en rajoutant des extern là où il faut.
Pour inclure ça à l'édition des liens, tu as le choix :
- soit tu lies les fichiers objet comme tu le fais avec les fichiers objet de ton application,
- soit tu fais une bibliothèque statique :
ar r libtoto.a *.o
- soit tu fais une bibliothèque dynamique, c'est le mieux car c'est plus économe en mémoire, le linker dynamique ne charge que les fonctions utilisées ; pour ça il faut avoir compilé du position independent code (option -fPIC), puis tu fais :
gcc -o libtoto.so.3.5 -shared -Wl,-soname,libtoto.so *.o -lc
puis les liens symboliques libtoto.so => libtoto.so.3 => libtoto.3.5
Marsh Posté le 06-09-2002 à 22:43:51
Jar Jar a écrit a écrit : Oui c'est ça, les .h ne contiennent que des prototypes, qui ne servent qu'à vérifier que l'utilisation de la fonction en C n'est pas incorrecte. En fait, on peut même les omettre et faire des déclarations implicites (GROUIIIIIIIIIIIIIIIIIIIIKKKKKKK). C'est au moment de l'édition des liens que le linker va chercher les fonctions correspondantes. Par défaut, il va au moins farfouiller dans la libc, mais on peut lui préciser des bibliothèques en plus, en lui donnant le chemin : /usr/lib/libtoto.a pour la version statique, /usr/lib/libtoto.so pour la version dynamique, ou tout simplement comme on fait habituellement, -ltoto. |
Et donc, dans la mesure où je crée ma propre librairie, que dois-je faire pour permettre de l'utiliser ?
Dois-je simplement créer les fichiers *.c et les ajouter dans les options ligne de commande de gcc en plus de main.c (autrement dit ne pas créer de fichier header) ?
Merci.
Marsh Posté le 06-09-2002 à 22:44:35
Jar Jar a écrit a écrit : Pour faire les .h, en gros tu reprends les déclarations de toutes tes fonctions, en rajoutant des extern là où il faut. Pour inclure ça à l'édition des liens, tu as le choix : - soit tu lies les fichiers objet comme tu le fais avec les fichiers objet de ton application, - soit tu fais une bibliothèque statique : ar r libtoto.a *.o - soit tu fais une bibliothèque dynamique, c'est le mieux car c'est plus économe en mémoire, le linker dynamique ne charge que les fonctions utilisées ; pour ça il faut avoir compilé du position independent code (option -fPIC), puis tu fais : gcc -o libtoto.so.3.5 -shared -Wl,-soname,libtoto.so *.o -lc puis les liens symboliques libtoto.so => libtoto.so.3 => libtoto.3.5 |
T'es pas obligé
le header peut contenir le code source des fonctions...
Marsh Posté le 06-09-2002 à 22:46:04
[SDF]Poire a écrit a écrit : T'es pas obligé le header peut contenir le code source des fonctions... |
GROUIIIIIIIIIIIIKKKKK
Tiens, j'ai oublié de préciser un HAINAURME avantage de faire des bibliothèques dynamiques : tu peux trafiquer ta bibliothèque sans toucher au logiciel déjà compilé...
Marsh Posté le 06-09-2002 à 22:46:25
Exemple d'un header (de moi en + enfin me suis aidé quand même hein...)
MP3.h:
Code :
|
Marsh Posté le 06-09-2002 à 22:48:49
Jar Jar a écrit a écrit : GROUIIIIIIIIIIIIKKKKK Tiens, j'ai oublié de préciser un HAINAURME avantage de faire des bibliothèques dynamiques : tu peux trafiquer ta bibliothèque sans toucher au logiciel déjà compilé... |
ça dépend de ce qu'il veut faire aussi
Marsh Posté le 06-09-2002 à 22:49:19
juju-le-barbare a écrit a écrit : Et donc, dans la mesure où je crée ma propre librairie, que dois-je faire pour permettre de l'utiliser ? Dois-je simplement créer les fichiers *.c et les ajouter dans les options ligne de commande de gcc en plus de main.c (autrement dit ne pas créer de fichier header) ? |
Dans tous les cas, il faut créer un fichier header qui contient les prototypes des fonctions que tu veux exporter.
Exemple con :
Code :
|
Ça donne :
Code :
|
Et c'est tout, pas de code pour toto, et pas de prototype pour foobar qui est statique.
Ensuite, tu as le choix entre les 3 méthodes que je t'ai données. Pour une petite lib, tu peux te contenter de compiler les fichiers ensemble, mais pour une grosse la bibliothèque dynamique finit par devenir indispensable.
Edit: j'avais oublié les _TOTO_H.
Marsh Posté le 06-09-2002 à 22:50:54
Jar Jar a écrit a écrit : Dans tous les cas, il faut créer un fichier header qui contient les prototypes des fonctions que tu veux exporter. Exemple con : [..] Ensuite, tu as le choix entre les 3 méthodes que je t'ai données. Pour une petite lib, tu peux te contenter de compiler les fichiers ensemble, mais pour une grosse la bibliothèque dynamique finit par devenir indispensable. |
J'aimerais bien savoir ce qu'il y a ds la bibliothéque...
C ptet bien se compliquer la vie pour pas grand chose...
Marsh Posté le 06-09-2002 à 22:57:00
[SDF]Poire a écrit a écrit : J'aimerais bien savoir ce qu'il y a ds la bibliothéque... C ptet bien se compliquer la vie pour pas grand chose... |
C'est une assez grosse bibliothèque (85 Ko de code sur plein de fichiers, et c'est loin d'être fini), je vais donc étudier toutes vos suggestions et je vous tiens au courant.
Merci à vous
Marsh Posté le 06-09-2002 à 22:58:19
juju-le-barbare a écrit a écrit : C'est une assez grosse bibliothèque (85 Ko de code sur plein de fichiers, et c'est loin d'être fini), je vais donc étudier toutes vos suggestions et je vous tiens au courant. Merci à vous |
ds ce cas là ça peut être intéressent
Marsh Posté le 07-09-2002 à 00:02:22
juju-le-barbare a écrit a écrit : Et donc, dans la mesure où je crée ma propre librairie, que dois-je faire pour permettre de l'utiliser ? Dois-je simplement créer les fichiers *.c et les ajouter dans les options ligne de commande de gcc en plus de main.c (autrement dit ne pas créer de fichier header) ? Merci. |
pour faire ca proprement, tu dois:
- creer un fichier header pour chaque fichier.c ( ou regrouper par fonctions)
- include le header dans chaque .c utilisant les fonctions d'un autre
lors de la compilation, tu transformes tout en code objet:
gcc -c fichier.c -o fichier.o
et le linkage (rassemblement de tout ca):
gcc machin.o truc.o , etc...
pour une bibliotheque c'est pareil a part que tu compiles les fichiers.c avec l'option -fPIC et que tu ajoutes -shared a l'edition des liens
Marsh Posté le 07-09-2002 à 02:23:22
juju-le-barbare
Le header n'indique absolument pas où se trouve le code, juste la forme de l'appel.
La plupart des environnements de développements ont une notion de projet, qui spécifie dans quels fichiers sont cherchés les codes des fonctions.
[SDF]Poire a écrit a écrit : le header peut contenir le code source des fonctions... |
Si tu fais cette GROUIIIIIIIIIIIIKKKKKerie, saches que chaque source qui inclus ce header compilera sa propre version locale de cette fonction (duplication de code), et qu'il faut donc la déclarer static.
Jar Jar
toto.c devrait inclure toto.h, ça permet de vérifier la cohérence.
Légers inconvénient d'une DLL:
-petit surcoût dû à l'indirection.
-empêche l'inlining.
Marsh Posté le 07-09-2002 à 02:31:31
Musaran a écrit a écrit : Légers inconvénient d'une DLL: -petit surcoût dû à l'indirection. -empêche l'inlining. |
Le surcoût du à l'indirection est seulement présent sur l'architecture ia32. Avec tous les autres processeurs, ça n'engendre pas de pertes de performances.
Sinon, il me semble que libtool bidouille pour supprimer ce surcoût, mais ce n'est pas sa raison première.
Pour l'inlining, ça n'empêche pas d'inliner les fonctions statiques à la bibliothèque, si ?
Marsh Posté le 07-09-2002 à 08:23:17
<i>le header peut contenir le code source des fonctions...</i>
Jar Jar a écrit a écrit : GROUIIIIIIIIIIIIKKKKK |
gcc && C++ && utilisation de templates :+)
Marsh Posté le 07-09-2002 à 10:00:06
Merci,
Petite précision que j'avais omi, je suis sous environnement Unix (GNU/Linux pour être précis), mais vous l'aviez deviné (comment, je le sais pas...).
Bref désolé de vous paraître lourd, mais c'est la première fois que je créé une librairie
Donc je créé un fichier fonctions1.c qui contient par exemple 10 fonctions, puis 1 fichier fonctions1.h qui contient la déclaration de ces fonctions.
Mais pour indiquer que fonctions1.h doit être "lié" à fonctions1.c, dois-je faire un #include "fonctions1.h" au début du fichier fonctions1.c ?
De même tous les fichiers fonctionsn.c nécéssitent tous le même et unique fichier base.c (et son header base.h), je dois donc inclure base.h dans chaque fonctionsn.c c'est ça ?
J'espère avoir été clair, et je vous remercie tous autant que vous êtes pour m'avoir aidé
Marsh Posté le 07-09-2002 à 11:25:02
Bonjour,
J'ai à peu près trouvé, voici comment j'ai fait :
Dans chaque fonctionn.c j'ai inclus fonctionsn.h
et dans chaque fonctionsn.h, j'ai inclus base.c
(je ne peux pas inclure base.c dans fonctionsn.c, j'ai des erreurs)
En effet, chaque fichier fonctionsn.h dépend de base.h
Dans base.c j'ai inclus base.h
Et dans base.h je n'ai inclus que les headers standards (stdio.h, ...).
Le petit problème qui apparaît lorsque je tape :
gcc -fPIC -c fonctions1.c -o fonctions1.o
c'est que le fichier fonctions1.c nécéssite des fonctions de fonctions2.c.
Mais si j'inclus fonctions2.h ou fonctions2.c dans fonctions1.h ou dans fonctions1.c
(autrement dit les 4 possibilités), gcc m'indique des problèmes de redéfinitions.
Ne pas oublier que fonctions2.h inclus aussi base.h !
Donc dois-je utiliser des commandes du préprocesseur pour éviter celà ?
Si oui, que dois-je taper exactement ?
Merci !
Marsh Posté le 07-09-2002 à 13:09:38
1 - on n'inclut pas le .c dans le .h
2 - on protege ses headers contres les inclusions recursives:
Code :
|
3 - on spécifie static toutes les fonctions qui sont spécifiques à un module. (toutes celles dont le prototype n'est pas dans le header)
4 - plutot que de se taper les gcc -?? à la main on se fait un makefile ou on utilise des outils plus évolués (un ide?).
LeGreg
Marsh Posté le 07-09-2002 à 14:38:54
juju-le-barbare a écrit a écrit : Par exemple #define <stdlib.h> va inclure le fichier header stdlib.h au début de notre fichier. |
Il est bizzare ton compilo!
Marsh Posté le 07-09-2002 à 15:09:58
Ace17 a écrit a écrit : Il est bizzare ton compilo! |
Oups, merde, me suis trompé : c'est '#include' que je voulais dire ...
Marsh Posté le 07-09-2002 à 15:16:16
legreg a écrit a écrit : 1 - on n'inclut pas le .c dans le .h 2 - on protege ses headers contres les inclusions recursives:
|
Donc, dans chaque fichier 'fonctionsn.h', je dois taper
#ifndef MONHEADER_H
#define MONHEADER_H
// ... ici mes declarations de fonctions
#endif MONHEADER_H
Mais à quoi correspond 'MONHEADER_H', et dans '... ici mes declarations de fonctions', que dois-je mettre : un '#include "base.h"' ?
Sinon, que dois-je mettre ?
Mieux : où pourrais-je trouver de la doc sur les commandes du préprocesseur ?
Merci !
Marsh Posté le 07-09-2002 à 16:11:58
juju-le-barbare a écrit a écrit : Mieux : où pourrais-je trouver de la doc sur les commandes du préprocesseur ? |
info gcc
Sinon, pour tes problèmes de fichiers .h, c'est comme quand tu fais un soft... À chaque fichiers fonctionsN.c tu associe un fonctionsN.h (mais ça tu dois avoir compris), et dans ledit fichier, tu fais :
#ifndef _FONCTIONSN_H /* en changeant le N à chaque fois ! */
#define _FONCTIONSN_H
...
#endif /* _FONCTIONSN_H */
Ensuite, tu peux te faire un toto.h, qui contient :
#ifndef _TOTO_H
#define _TOTO_H
#include <toto/fonctions1.h>
#include <toto/fonctions2.h>
...
#endif /* _TOTO_H */
Bien entendu, n'oublie pas de mettre tes h dans un sous répertoire include/toto, et de faire un -I${srcdir}/include dans tes compilations.
Ensuite, tu inclus ton toto.h, d'une part dans tous les fichiers .c de la bibliothèque, d'autre part dans tous les programmes qui utilisent ladite bibliothèque.
Si tu as vraiment du mal, n'hésite pas à regarder le code des Makefile d'une bibliothèque simple, tu comprendras plus vite avec UTSL qu'avec des heures d'explications.
Marsh Posté le 07-09-2002 à 20:53:56
Juju, dans ton post initial, tu as mis #define au lieu de #include.
Moi aussi je recommande la syntaxe
#ifndef MON_FICHIER_H_A_INCLURE
#define MON_FICHIER_H_A_INCLURE
..............
#endif /* MON_FICHIER_H_A_INCLURE */
J'ai encontré ce genre de pratique systematique pour la premiere fois dans l'implementation de XWindows il y a une quinzaine d'années.
A+,
Marsh Posté le 07-09-2002 à 21:06:33
juju-le-barbare a écrit a écrit : Bonjour, J'ai à peu près trouvé, voici comment j'ai fait : Dans chaque fonctionn.c j'ai inclus fonctionsn.h et dans chaque fonctionsn.h, j'ai inclus base.c (je ne peux pas inclure base.c dans fonctionsn.c, j'ai des erreurs) En effet, chaque fichier fonctionsn.h dépend de base.h Dans base.c j'ai inclus base.h Et dans base.h je n'ai inclus que les headers standards (stdio.h, ...). Le petit problème qui apparaît lorsque je tape : gcc -fPIC -c fonctions1.c -o fonctions1.o c'est que le fichier fonctions1.c nécéssite des fonctions de fonctions2.c. Mais si j'inclus fonctions2.h ou fonctions2.c dans fonctions1.h ou dans fonctions1.c (autrement dit les 4 possibilités), gcc m'indique des problèmes de redéfinitions. Ne pas oublier que fonctions2.h inclus aussi base.h ! Donc dois-je utiliser des commandes du préprocesseur pour éviter celà ? Si oui, que dois-je taper exactement ? Merci ! |
D'autre part, juju, tu ne devrais pas avoir a inclure un .c dans un .h. Il y a certainement un pb dans la structuration de ton programme,
Tu devrais avoir uniquement a inclure base.h comme ceci:
dans fonction1.c :
/* headers des librairies standard utilisées */
#include "base.h" /* perso, je preferre des includes explicites avec #include <stdio.h>,... partout */
/* headers des fonctions et datatypes externes */
#include "fonction2.h"
.....................
/* headers des fonctions et datatypes locales */
#include "fonction1.h" /* devrait etre ton dernier #include */
A+,
Marsh Posté le 08-09-2002 à 00:56:10
Merci,
Je tiens précieusemnt compte de vos remarques, merci encore.
Je vous tient au courant en cas d'échec (on sait jamais )
@++
Marsh Posté le 08-09-2002 à 04:00:52
legreg, Jar Jar, gilou et tous les autres
Code :
|
J'aimerais savoir s'il y a moyen d'automatiser cette formule, de générer automatiquement un identifiant, pour ne pas avoir besoin de choisir de nom.
Je pensais à la macro __FILE__, mais:
1) Elle donne une chaîne, et il n'y a pas d'opérateur de dé-chaînage.
2) Les caractères accentués et les sigles (dont le point du ".h" ) donneraient une erreur de compilation.
3) Les espaces tronqueraient le nom: risque d'homonymie.
Des idées ?
Marsh Posté le 08-09-2002 à 04:03:22
juju-le-barbare a écrit a écrit : Mais pour indiquer que fonctions1.h doit être "lié" à fonctions1.c, dois-je faire un #include "fonctions1.h" au début du fichier fonctions1.c ? |
C'est dans l'autre sens:
'fonctions1.c' fait '#include "fonctions1.h"' pour utiliser ce qu'il y a dedans.
La relation inverse n'existe pas dans le langage, c'est le système de compilation qui doit trouver les bonnes fonctions dans les sources qu'on lui indique.
Les headers ne doivent contenir que des trucs ne générant pas de code:
Code :
|
Sinon quoi ?
Eh bien chaque source l'incluant compilera un exemplaire du truc pour lui-même, et l'éditeur de liens ne saura pas quelle version choisir, car il ne doit y en avoir qu'une !
Ce système est vieux et pourri, mais il faut faire avec.
Marsh Posté le 08-09-2002 à 04:04:45
kadreg a écrit a écrit : gcc && C++ && utilisation de templates :+) |
C'est plus une fonction, mais un patron de fonctions.
C'est très différent.
Un patron n'étant pas directement compilé, il a sa place dans le header.
On obtient le même effet (en moins bien) avec inline.
Le C++ est merveilleux de complexité, non ?
Marsh Posté le 08-09-2002 à 04:21:33
Jar Jar a écrit a écrit : Le surcoût du à l'indirection est seulement présent sur l'architecture ia32. Avec tous les autres processeurs, ça n'engendre pas de pertes de performances. |
Indirection: passer par un élément intermédiaire.
Typiquement un pointeur: Le lire, chercher l'élément à l'adresse indiquée.
Ce pointeur étant variable (dynamisme), il faut bien le lire, le processeur peut juste offrir un moyen rapide de le faire.
Une DLL étant dynamique (...), elle passe au moins par une telle indirection.
Le mécanisme virtuel du C++ utilises une telle indirection.
Mais bon... le surcoût équivaut à la lecture d'un pointeur, c'est très minime.
Citation : Sinon, il me semble que libtool bidouille pour supprimer ce surcoût, mais ce n'est pas sa raison première. |
je ne vois que la liaison statique pour ça...
Citation : Pour l'inlining, ça n'empêche pas d'inliner les fonctions statiques à la bibliothèque, si ? |
Effectivement pas.
Seul l'appel dynamique n'est pas compatible avec l'inlining (notion statique).
Marsh Posté le 08-09-2002 à 07:22:01
Musaran a écrit a écrit : legreg, Jar Jar, gilou et tous les autres
|
Tu cherches un utilitaire nommé proto (le source c traine sur le web, GNU?) et tu le customizes.
A+,
Marsh Posté le 08-09-2002 à 10:45:57
Musaran a écrit a écrit : Indirection: passer par un élément intermédiaire. Typiquement un pointeur: Le lire, chercher l'élément à l'adresse indiquée. Ce pointeur étant variable (dynamisme), il faut bien le lire, le processeur peut juste offrir un moyen rapide de le faire. |
Tu veux parler du fait qu'il va chercher la fonction dans la table des symboles à chaque appel ?
Effectivement, je croyais que l'éditeur de liens dynamiques se démerdait pour ne pas requérir une telle indirection, mais à la réflexion je ne vois pas trop comment ce serait faisable...
Pour ma part, je pensais au fait qu'ia32 ne gère pas tout seul le code indépendant de la position, et qu'il y a donc un surcoût à chaque appel de fonction à l'intérieur de la bibliothèque, car il faut calculer l'endroit où sauter à chaque fois. Ça n'est effectivement pas une indirection, mais c'est quand même un surcoût à ne pas oublier.
Musaran a écrit a écrit :
je ne vois que la liaison statique pour ça... |
libtool est un mic-mac immonde, je n'ai jamais bien compris comment ça marche, mais il me semble qu'au final on se ramène à quelque chose qui ressemble à un binaire statique. Il est conçu au départ pour que les systèmes qui ne connaissent pas les bibliothèques dynamiques puissent en bénéficier quand même.
Marsh Posté le 08-09-2002 à 12:45:20
Salut,
Je vous promet que j'ai fait omme vous m'avez dit, mais ça ne marche pas !
J'ai du oublier un tout petit élément...
Je ne sais pas où trouver de librairie à compiler avec un Makefile.
De plus j'ai quelques questions :
si je fais un
#define _FONCTION1_H
A quoi correspond exactement le _FONCTION1_H ?
Sinon je vais vous montrer ce que j'ai fait, corrigez-moi (je sais j'abuse ) :
Code :
|
Code :
|
Code :
|
Code :
|
Et toutes les autres filles de la même manière.
J'ai mis les fichiers base.c, base.h, filles.c , filles.h, dans le dossier /home/coder/libr/include/
Et dans le dossier /home/coder/libr/ j'ai créé un fichier libr.h qui contient :
Code :
|
Mais donc que dois-je faire pour compiler ma librairie dynamique ?
Dois-je compiler chaque .c du dossier include ?
De même quelle est l'utilité des .h, ne pourrai-je pas tout mettre dans les .c, sans déclaration ?
Merci
@++
Marsh Posté le 08-09-2002 à 13:15:33
Musaran a écrit a écrit : [g] J'aimerais savoir s'il y a moyen d'automatiser cette formule, de générer automatiquement un identifiant, pour ne pas avoir besoin de choisir de nom. |
sous visual, par exemple, quand tu lui demandes de creer une classe il t'invente un identifiant unique a partir du nom
de fichier et te place les ifndef lui meme.
Une forme pas beaucoup plus portable c'est
de spécifier "#pragma once" dans le header
ce qui indique au preprocesseur qu'il ne faudra l'inclure
qu'une seule fois par unité ce qui permet au moins pour les projets visual de ne pas taper les "#ifndef..."
Mais je suppose que tu savais deja tout ca ??
Citation : si je fais un |
Il ne correspond a rien. C'est le seul endroit ou il est utilisé et ne fait reference a rien de particulier.
On choisit le nom en fonction du fichier d'inclusion (fonction.h -> FONCTION_H_RANDOMID)
tout simplement pour qu'il ne puisse pas y avoir de cas de collisions entre deux identifiants identiques pour deux fichiers differents parfois on rajoute un RANDOMID pour limiter encore plus les cas de collisions (genere par macro ou par l'ide).
Code :
|
Mais tu defines quoi??
LeGreg
Marsh Posté le 08-09-2002 à 13:26:39
legreg a écrit a écrit :
|
Et bien je définit les prototypes des fonctions qui se trouvent dans fille1.c
C'est bien ça qu'il faut faire non ?
Marsh Posté le 06-09-2002 à 21:24:28
Bonjour,
Lorsque l'on programme en C, il est très souvent nécéssaire d'employer au début de notre fichier
de l'application la commande du préprocesseur #define, suivie de fichiers headers de diverses
librairies.
Par exemple #define <stdlib.h> va inclure le fichier header stdlib.h au début de notre fichier.
Mais ce fichier stdlib.h ne contient que la déclaration des fonctions et données, et non ces fonctions
en elles-même !
J'imagine que les corps de ces fonctions se trouvent dans un fichier du type stdlib.c
J'aimerai savoir comment se débrouille le fichier stdlib.h pour indiquer d'utiliser le fichier stdlib.c,
de sorte que dans l'application on n'a qu'à inclure le fichier header (et non stdlib.c) ???
Merci
---------------
Du temps à perdre ? -> http://www.juju-le-barbare.fr.fm