Comment faire pour déplacer les fonctions C en fichier séparé?

La façon la plus courante consiste à placer vos prototypes de fonction dans un fichier d'en-tête et de vos implémentations de fonction dans un fichier source. Par exemple:

func1.h

#ifndef MY_FUNC1_H
#define MY_FUNC1_H
#include <stdio.h>

//declares a variable
extern int var1;

//declares a function
void func1(void);
#endif

func1.c

#include "func1.h"

//defines a variable
int var1 = 512;

//defines a function
void func1(void) {
    printf("Function 1!\n");
}

func2.h:

#ifndef MY_FUNC2_H
#define MY_FUNC2_H
#include <stdio.h>
void func2(void);
#endif

func2.c:

#include "func1.h" //included in order to use var1
#include "func2.h"
void func2(void) {
    printf("Function 2 with var1 == %i\n", var1);
}

principal.c:

#include <stdio.h>
#include "func1.h"
#include "func2.h"

int main(void) {
    var1 += 512;
    func1();
    func2();
    return 0;
}

Vous pouvez alors compiler à l'aide de l'suivantes:

gcc -c -o func1.o func1.c
gcc -c -o func2.o func2.c
gcc -c -o main.o  main.c
gcc -o myprog main.o func1.o func2.o
./myprog

J'ai seulement mis une fonction au sein de chaque source/en-tête de la paire pour l'illustration. Vous pourriez créer un en-tête qui comprend les prototypes pour tous les fichiers source, ou vous pouvez créer plusieurs fichiers d'en-tête de chaque fichier source. La clé est que n'importe quel fichier source qui va appeler la fonction, doit inclure un fichier d'en-tête qui comprend le prototype de la fonction.

En règle générale, vous voulez seulement un fichier d'en-tête inclus une fois, c'est le but de la #ifndef #define #endif macros dans les fichiers d'en-tête.

OriginalL'auteur David M. Syzdek

Vous pouvez faire deux fichiers: l'un avec la fonction principale, et une autre avec les autres.

Si votre fonction dans un autre fichier utilise une variable globale à partir d'un autre module/fichier, vous devez ajouter "extern" devant la déclaration de variable globale dans le module avec la définition de la fonction. Elle indique au compilateur que vous avez accès à une variable globale à partir d'un autre fichier.

Ce qui suit est un exemple de cas où une variable globale, "x", est défini et une fonction "mafonction, est appelé dans la main.c fichier. "myfunction" est défini dans les fonctions.c fichier. "x" doit également être déclarée dans les fonctions.c fichier, mais comme il sera accédant à "x" à partir d'un autre fichier, il faut avoir une "extern" en face d'elle. "myfunction" prend de l'externe variable globale "x", il incrémente par l'un et l'imprime. Considérons le code suivant:

principal.c aura l'air quelque chose comme:

#include <stdio.h>
#include "functions.c"

int x = 1;

int main()
{
    myfunction();
    printf("The value of x in main is: %d\n", x);
    return(0);
}

fonctions.c ressemblera à quelque chose comme:

#include <stdio.h>

extern int x;

void myfunction(void)
{
        x++;
    printf("The value of x in myfunction is: %d\n",x);
}

Noter que les principaux.c utilise "int x;" déclarer x alors que les fonctions.c utilise "extern int x" pour déclarer x.

Pour compiler le code, assurez-vous que les deux fichiers sont dans le même dossier et de compiler tout comme vous le feriez si vous n'aviez qu'un seul fichier. Par exemple, si vous utilisez gcc sur un système linux et gcc, votre entrée de ligne de commande ressemblera à:

gcc main.c -o main
./main

La première ligne compile le code, et la deuxième ligne de l'exécute. La sortie devrait ressembler à:

La valeur de x dans la fonction myfunction est: 2
La valeur de x dans la principale est: 2

Noter que la Valeur de "x" est également changé de main en tant que "x" est une variable globale.

OriginalL'auteur Aniq Ahsan