web-dev-qa-db-fra.com

Compilation de plusieurs fichiers C dans un programme

J'ai les deux fichiers suivants:

fichier1.c

int main(){
  foo();
  return 0;
}

fichier2.c

void foo(){

 }

Puis-je compiler et lier les deux fichiers afin que le file1.c reconnaîtra la fonction foo sans ajouter extern?

Mise à jour du prototype.

gcc file1.c file2.c lance: avertissement: déclaration implicite de la fonction foo.

16
mary

Vous n'avez pas besoin d'un extern, mais file1.c doit voir une déclaration que foo() existe. Habituellement, cette déclaration se trouve dans un fichier d'en-tête.

Pour ajouter une déclaration directe sans utiliser de fichier d'en-tête, modifiez simplement file1.c en:

int foo();  // add this declaration

int main(){
  foo();
  return 0;
}
7
chrisaycock

La bonne façon est la suivante:

file1.c

#include <stdio.h>
#include "file2.h"

int main(void){
    printf("%s:%s:%d \n", __FILE__, __FUNCTION__, __LINE__);
    foo();
    return 0;
}

file2.h

void foo(void);

file2.c

#include <stdio.h>
#include "file2.h"

void foo(void) {
    printf("%s:%s:%d \n", __FILE__, __func__, __LINE__);
    return;
}

output

$
$ gcc file1.c file2.c -o file -Wall
$
$ ./file 
file1.c:main:6 
file2.c:foo:6 
$ 
31

Vous pouvez, mais vous ne devriez pas.

Utilisez un fichier d'en-tête, file2.h:

// file2.h

void foo(); // prototype for function foo()

Puis ajouter:

#include "file2.h" 

dans file1.c

Compiler:

$ gcc -Wall file1.c file2.c -o foo

En règle générale, il est préférable (plus robuste) d'utiliser un fichier d'en-tête pour définir les interface de chaque module plutôt que ad hoc prototypes dans les dépendants modules. Ceci est parfois connu sous le nom de principe SPOT (Single Point Of Truth).

6
Paul R

C'est moche, mais en utilisant gcc, vous pourriez:

gcc -include file2.c file1.c

-include est un indicateur du préprocesseur qui inclura le contenu de file2.c tout en haut de file1.c. Cela dit, c'est un mauvais choix et se décompose pour tous, sauf le plus simple des programmes.

2
Dave