Créer votre propre fichier d'en-tête en C

Réponses:

300

foo.h

#ifndef FOO_H_   /* Include guard */
#define FOO_H_

int foo(int x);  /* An example function declaration */

#endif // FOO_H_

toto.c

#include "foo.h"  /* Include the header (not strictly necessary here) */

int foo(int x)    /* Function definition */
{
    return x + 5;
}

principal c

#include <stdio.h>
#include "foo.h"  /* Include the header here, to obtain the function declaration */

int main(void)
{
    int y = foo(3);  /* Use the function here */
    printf("%d\n", y);
    return 0;
}

Pour compiler avec GCC

gcc -o my_app main.c foo.c
Oliver Charlesworth
la source
2
@Anu: Je ne peux pas lire ça dans ce format. Vous pouvez modifier votre question d'origine pour inclure ce code.
Oliver Charlesworth
3
Il est à noter que ce code ne fonctionne pas si vous essayez de le construire simplement par bouton ("build and run" dans Code :: Blocks par exemple). Cela peut sembler évident pour vous, mais pour moi, c'est la première fois que cela se produit et il m'a fallu un certain temps pour comprendre où est le problème.
Jeyekomon
5
@Jeyekomon: Eh bien, où est le problème?
Oliver Charlesworth
2
Personne ne m'a dit que le bouton "build and run" ne suffit pas pour tout. :-) Ce fut une surprise pour moi (je suis un débutant). Maintenant, je suppose que je dois d'abord apprendre à utiliser la ligne de commande ou les makefiles.
Jeyekomon
1
Je me demandais si vous pouviez expliquer comment compiler avec tous les fichiers requis et ne pas avoir à inclure foo.c dans l'argument du programme gcc. Comment s'appelle cette technique ou quel programme peut accomplir cela en dehors de l'EDI - Make me vient à l'esprit
nf071590
26 
#ifndef MY_HEADER_H
# define MY_HEADER_H

//put your function headers here

#endif

MY_HEADER_H sert de garde à double inclusion.

Pour la déclaration de fonction, il vous suffit de définir la signature, c'est-à-dire sans nom de paramètre, comme ceci:

int foo(char*);

Si vous le souhaitez vraiment, vous pouvez également inclure l'identifiant du paramètre, mais ce n'est pas nécessaire car l'identifiant ne serait utilisé que dans le corps d'une fonction (implémentation), qui dans le cas d'un en-tête (signature de paramètre), il est manquant.

Ceci déclare la fonction fooqui accepte a char*et retourne un int.

Dans votre fichier source, vous auriez:

#include "my_header.h"

int foo(char* name) {
   //do stuff
   return 0;
}
Flavius
la source
Ils sont connus sous le nom de déclarations de fonctions ou de prototypes de fonctions , et non d '"en-têtes de fonctions". Les en-têtes sont les fichiers que vous incluez, pas les déclarations qu'ils contiennent.
Jonathan Wakely
@JonathanWakely Ce sont les fichiers d'en-tête. Le nom dit tout: les fichiers d'en-tête contiennent des en-têtes. Mais merci pour les retours, cela m'a fait réfléchir une seconde.
Flavius
Non, les en-têtes sont les fichiers eux-mêmes, pas les déclarations qu'ils contiennent. Pouvez-vous trouver une seule référence fiable pour sauvegarder votre utilisation de "header"? C'est contredit par K&R, le standard C, l' environnement de programmation UNIX et Wikipedia , par exemple.
Jonathan Wakely
@JonathanWakely avez-vous réellement lu K&R? La table des matières comporte une section «4.5 Fichiers d'en-tête» et «Fichiers d'en-tête» est écrit en italique, indiquant la terminologie. Dans le reste du livre, les auteurs écrivent parfois juste "en-tête" par souci de concision, mais grâce au formatage et à la table des matières, il est clair quelle est la bonne terminologie. Alors s'il vous plaît, soyez un professionnel et reconnaissez quand vous vous trompez.
Flavius
Oui, et "en-tête" fait référence aux fichiers , pas aux déclarations qu'ils contiennent. Dans la 2ème édition voir page 241 pour la discussion des en-têtes standard, et page 33 qui parle des définitions et déclarations (que vous appelez par erreur "en-têtes de fonction") et définit clairement un en- tête : "La pratique habituelle est de collecter les externdéclarations de variables et fonctions dans un fichier séparé, historiquement appelé un en- tête , qui est inclus par #includeau début de chaque fichier source. Les fonctions de la bibliothèque standard, par exemple, sont déclarées dans des en-têtes comme <stdio.h>. "
Jonathan Wakely
8

myfile.h

#ifndef _myfile_h
#define _myfile_h

void function();

#endif

monfichier.c

#include "myfile.h"

void function() {

}
TommyGunn32
la source
void function();comme une déclaration n'empêche pas les appels comme function(42);. Utiliser voiddans la déclaration commevoid function(void);
chux - Réintégrer Monica
5

Les fichiers d'en-tête contiennent des prototypes pour les fonctions que vous définissez dans un fichier .c ou .cpp / .cxx (selon que vous utilisez c ou c ++). Vous voulez placer # ifndef / # définit autour de votre code .h de sorte que si vous incluez le même .h deux fois dans différentes parties de vos programmes, les prototypes ne sont inclus qu'une seule fois.

client.h

#ifndef CLIENT_H
#define CLIENT_H

short socketConnect(char *host,unsigned short port,char *sendbuf,char *recievebuf, long rbufsize);


#endif /** CLIENT_H */

Ensuite, vous implémenteriez le .h dans un fichier .c comme ceci:

client.c

#include "client.h"

short socketConnect(char *host,unsigned short port,char *sendbuf,char *recievebuf, long rbufsize) {
 short ret = -1;
 //some implementation here
 return ret;
}
djsumdog
la source
"de sorte que si vous incluez deux fois le même .h dans différentes parties de vos programmes, les prototypes ne sont inclus qu'une seule fois." C'est trompeur. Ils se gardent d'inclure le même fichier d'en-tête deux fois à partir du même fichier source (y compris un en-tête deux fois dans deux fichiers sources différents est ok, et généralement requis!) Et la re-déclaration des prototypes de fonctions n'est pas un problème, redéfinir les types et les variables globales est ce contre quoi il faut se garder.
Jonathan Wakely