Utilisation d’un mot clé extern pour appeler des fonctions

Je souhaite appeler les fonctions définies dans test.c depuis other.c.

Puis-je extern la function1 pour l’appeler? De plus, dois-je utiliser extern dans function2 et function3 , qui sont appelées par function1 ?

autre.c

 extern function1(); function1(); 

test.c

 void function1() { function2(); function3(); } void function2() { } void function3() { } 

    Les déclarations de fonction sont “par défaut” extern .

    Citant C11 , chapitre §6.2.2 ( souligné par moi )

    Si la déclaration d’un identifiant pour une fonction n’a pas de spécificateur de classe de stockage , sa liaison est déterminée exactement comme si elle avait été déclarée avec le spécificateur de classe de stockage extern . […]

    Donc, vous n’avez pas besoin d’être explicite à ce sujet.

    Vous devez comstackr les unités de traduction, c’est-à-dire les fichiers sources (en fichiers objects), puis les lier entre elles pour créer l’exécutable. Ça devrait le faire.

    extern nous dit simplement qu’il est défini ailleurs. Et vous l’utilisez dans le fichier que vous écrivez en extern . Mais les fonctions sont par défaut extern. Donc, vous n’avez pas besoin d’être explicite à ce sujet.

    En fait, chaque fonction par défaut est extern 🙂 – à moins que vous ne le déclariez comme tel :). C’est suffisant si vous avez le prototype avant le premier appel;

     int xxx(int, int, float, double); // prototype int main(void) { int x,y; float z; double v; xxx(x,y,z,v); return 0; } 

    La fonction peut être dans un autre fichier .c. Vous devez inclure le fichier object à la liaison.

     int xxx(int a, int b, float c, double d) { int result; /* do something */ return result; } 

    Vous utilisez extern pour déclarer des symboles externes à l’ unité de traduction actuelle (à peu près un seul fichier source avec tous ses fichiers d’en-tête inclus).

    Exemple simple

    Le premier fichier source test1.c

     extern void function1(void); // "Import" a function from another translation unit int main(void) { function1(); // Can call the declared function } 

    Ensuite, le deuxième fichier source test2.c :

     void function2(void) { // Do something } void function1(void) { function2(); // No extern needed, it's declared (and defined) // in the same translation unit } 

    Comme vous pouvez le constater, la fonction function2 n’a besoin d’aucune déclaration extern . Il est utilisé uniquement dans test2.c donc seule la function1 doit en être test2.c .

    Cependant, dans test1.c la fonction main doit connaître la function1 car elle est appelée, puis nous effectuons une déclaration en test1.c de la fonction prototype. Ceci est fait en utilisant le mot clé extern . Mais pour la déclaration de fonctions, le mot-clé extern n’est pas réellement nécessaire, car ils sont toujours considérés comme “externes” (comme l’a noté Peter).