reference indefini lors de la compilation

Version imprimable

bonjour
lorsque que je compile mon programme il m'affiche ces erreurs et je n'arrive pas a trouver la solution

Citation:

gcc -pedantic -Wall -Wextra -Werror -std=c11 -o "main" "main.c" (dans le dossier : /home/chris/Bureau/algo)
/tmp/ccR1Ljql.o: dans la fonction « main »:
main.c:(.text+0x68): référence indéfinie vers « read_write »
main.c:(.text+0x74): référence indéfinie vers « chain »
main.c:(.text+0x93): référence indéfinie vers « affich_list »
collect2: error: ld returned 1 exit status
Compilation échouée.

merci d'avance pour votre aide

voici le code de mon main

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
#include <stdlib.h>
#include <stdio.h>
#include <assert.h>
#include <string.h>
#include "test.h"
 
 
 
int main(){
	FILE* fic = NULL;
	Pelt t = malloc(sizeof(elt));
	printf("8888 afic good");
	fic = fopen("test.txt","r");
	assert(fic!=NULL);
	read_write(fic);
	t=chain(fic);	
	printf("afic good");
	affich_list(t);
	fclose(fic);
	return EXIT_SUCCESS;
}

code de test.h

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
#include <stdlib.h>
#include <stdio.h>
#include <assert.h>
#include <string.h>
#ifndef TEST_H
#define TEST_H
 
 
typedef struct elt *Pelt;
typedef struct elt {
	char* nam;
	Pelt next;
}elt;
 
typedef struct liste{
	Pelt first;
	int size;
}*liste;
 
// fonction defini dans test.c
elt new_elt (char *n);
Pelt new_Pelt(elt e);
Pelt new_list();
Pelt add_vid(Pelt lister, elt te);
Pelt last_elt(Pelt l);
Pelt add_list_elt(Pelt list, elt e);
Pelt add(Pelt list, elt e);
Pelt add_Pelt(Pelt list, Pelt b);
void affich_list(Pelt r);
Pelt prev_elt(Pelt l, elt e);
Pelt suiv_elt(Pelt l, elt e);
Pelt ins_elt(Pelt l, elt e,elt h);
 
//fin des fonctions defini dans test.c
 
//fonction defini dans test_read_fich.c
FILE* read_write(FILE* f);
 
//fin fonction defini dans test_read_fich.c
 
//fonction defini dans full_chain.c
Pelt chain(FILE *p);
//fin fonction defini dans full_chain.c
#endif

code d'un des fichiers en .c

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
#include <stdlib.h>
#include <stdio.h>
#include <assert.h>
#include <string.h>
#include "test.h"
#include "test_read_fich.c"
#include "test.c"
#define TAILLE_MAX 28
 
Pelt chain(FILE *p){
	Pelt li = malloc(sizeof(elt));
	char *c =malloc(sizeof(char));
	fgets(c,TAILLE_MAX,p);
	elt f=new_elt(c);
	li=new_list();
	li=add(li,f);
	while((*c)!=EOF){
		f=new_elt(c);	
		li=add(li,f);	
		fgets(c,TAILLE_MAX,p);
	}
 
	return li;
}

17/11/2015, 16h14
ternel
référence indéfinie (undefined reference) signifie que l'éditeur de lien ne trouve pas la définition d'un symbole externe.
Ce sont des fonctions dont il ne trouve pas la définition, parce qu'elle ne fait pas partie des fichiers assemblés.

Sans réglages particulier, gcc compile tous les fichiers indiqués en un exécutable.

en l'occurence, la commande
```
gcc -pedantic -Wall -Wextra -Werror -std=c11 -o "main" "main.c"
```
c'est à dire
```
gcc -o "main" "main.c"
```
compile le binaire main a partir de main.c

Il manque tous les autres .c.

essaie de compiler en deux temps:
```
gcc -c *.c
gcc *.c -o main
```
c'est à dire
```
gcc -pedantic -Wall -Wextra -Werror -std=c11 -c *.c
gcc -pedantic -Wall -Wextra -Werror -std=c11 *.c -o main
```
17/11/2015, 19h12
Sve@r
Citation:

Envoyé par chrislains

bonjour

voici le code de mon main
code d'un des fichiers en .c

Bonjour

Une compilation se passe en 3 étapes
1. préprocesseur
2. analyse et création du module objet
3. assemblage de tous les objets, en y rajoutant aussi les librairies diverses (dont la standard) pour créer l'exécutable (étape nommée "édition des liens")
Généralement, quand le programme entier tient dans un seul source, les 3 étapes sont alors automatiquement déroulées en une seule opération et rien ne vient distinguer une étape ou une autre. Mais si le programme est séparé en plusieurs sources, alors il faut compiler chaque source en s'arrêtant à l'étape 2 (commande cc -c) puis en final, demander la dernière étape en y incluant manuellement tous les objets. Sinon l'éditeur de liens ne sait pas où trouver le code des fonctions définies dans les autres sources.

Exemple
Code:

1 2 3 4 5 cc -c main.c cc -c test.c cc -c read_fich.c cc -c full_chain.c cc main.o test.o read_fich.o full_chain.o -o nom_executable
(éventuellement avec gcc au lieu de cc et en y rajoutant si on le désire des options spécifiques de contrôle ou d'optimisation)

Ensuite, quand le nombre de sources devient trop important et que ça gonfle de devoir tout retaper à chaque fois (surtout que parfois c'est long de tout recompiler alors qu'un seul source est modifié), un outil nommé "make" permet, à partir d'un fichier "Makefile" configuré pour décrire qui dépend de quoi, permet alors d'automatiser la compilation intelligente (quand une branche est modifiée, seule celle-ci est alors recompilée)...