#1 Le 03/05/2020, à 22:09
- zephyre123
Aide message d'erreur du compilateur [RESOLU]
Bonjour,
Pour me former à l'informatique en langage C je suis les cours de jacque olivier lapeyre.
J'en suis au cour 37 ici https://www.youtube.com/watch?v=jCooZxK … -&index=37
Cependant il m'est impossible de faire comme lui c'est à dire de déplacer ceci :
- dans le fichier intarray.c on a définis un nouveau type comme suit typedef int intdata;
- dans le fichier jstr.c on a définis un nouveau type comme suit typedef char chardata;
Jacque olivier lapeyre place ces deux nouveaux types dans un fichier tools.h et la mon compilateur me dit que ce n'est pas possible ça génère plein d'erreur.
Hors lui quand il le fait aucun souci ça passe crème.
Le fichier intarray.c ci dessous :
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
#include "intarray.h"
#include "tools.h"
/*--------------------------------------------------------------------------------------------------------------*/
void intarray_debug (intarray * T)
{
for (int i = 0; i < T->len; i++)
printf("%d ", T->data[i]);
printf("Mémoire utilisé : %d et mémoire allouée : %d\n", T->len, T->alloc);
}
/*--------------------------------------------------------------------------------------------------------------*/
/*--------------------------------------------------------------------------------------------------------------*/
intarray * intarray_create_ext(int len, int alloc)
{
assert( (len >= 0) && (alloc > 0) && (len <= alloc) );
// Allocation de la mémoire de la structure de donnée
intarray * A = malloc(sizeof(*A));
// Fixation des champs
A->len = len;
A->alloc = alloc;
// Allocation mémoire du tableau data
A->data = malloc(sizeof(*(A->data)) * alloc);
return A;
}
/*--------------------------------------------------------------------------------------------------------------*/
/*--------------------------------------------------------------------------------------------------------------*/
intarray * intarray_create(int len)
{
intarray_create_ext(len, len);
}
/*--------------------------------------------------------------------------------------------------------------*/
intarray * intarray_standart_empty_create(void)
{
return intarray_create_ext(0, INTARRAY_DEFAULT_ALLOC);
}
/*--------------------------------------------------------------------------------------------------------------*/
void intarray_destroy(intarray * T)
{
free(T->data);
free(T);
}
/*--------------------------------------------------------------------------------------------------------------*/
/*--------------------------------------------------------------------------------------------------------------*/
int intarray_get(intarray * T, int i)
{
// Condition sur l'indice i
assert (i >= 0);
assert (i < T->len);
return T->data[i];
}
/*--------------------------------------------------------------------------------------------------------------*/
/*--------------------------------------------------------------------------------------------------------------*/
void intarray_set(intarray * T, int i, intdata n)
{
// CONDITION SUR L'INDICE I : (ajouter persos)
assert (i >= 0);
assert (i < T->len);
T->data[i] = n;
}
/*--------------------------------------------------------------------------------------------------------------*/
/*--------------------------------------------------------------------------------------------------------------*/
int intarray_lenght(intarray * T)
{
return T->len;
}
/*--------------------------------------------------------------------------------------------------------------*/
/*--------------------------------------------------------------------------------------------------------------*/
int intarray_get_min(intarray * T)
{
// INITIALISATION :
intdata min = intarray_get(T, 0);
for(int i = 1; i < intarray_lenght(T); i++)
if (intarray_get(T, i) < min)
min = intarray_get(T, i);
return min;
}
/*--------------------------------------------------------------------------------------------------------------*/
/*--------------------------------------------------------------------------------------------------------------*/
intarray * intarray_concate(intarray * T1, intarray * T2)
{
// Allocation du nouveau intarray
intarray * T = intarray_create(intarray_lenght(T1) + intarray_lenght(T2));
for(int i = 0; i < intarray_lenght(T1); i++)
intarray_set(T, i, intarray_get(T1, i));
int j = intarray_lenght(T1);
for(int i = 0; i < intarray_lenght(T2); i++)
{
intarray_set(T, j, intarray_get(T2, i));
j++;
}
return T;
}
/*--------------------------------------------------------------------------------------------------------------*/
/*--------------------------------------------------------------------------------------------------------------*/
int intarray_get_min_index(intarray * T, int start)
{
// INITIALISATION :
intdata min = T->data[start];
int indice_minimum = start;
for (int i = start + 1; i < intarray_lenght(T); i++)
{
if(T->data[i] < min)
{
min = T->data[i];
indice_minimum = i;
}
}
return indice_minimum;
}
/*--------------------------------------------------------------------------------------------------------------*/
/*--------------------------------------------------------------------------------------------------------------*/
void intarray_sort(intarray * T)
{
int index_min;
for(int i = 0; i < intarray_lenght(T) - 1; i++)
{
index_min = intarray_get_min_index(T, i);
int_swap(&(T->data[index_min]), &(T->data[i]));
}
}
/*--------------------------------------------------------------------------------------------------------------*/
/*--------------------------------------------------------------------------------------------------------------*/
int intarray_sum(intarray * T)
{
int somme = 0;
for(int i = 0; i < intarray_lenght(T); i++)
somme += T->data[i];
return somme;
}
/*--------------------------------------------------------------------------------------------------------------*/
/*--------------------------------------------------------------------------------------------------------------*/
int intarray_get_max(intarray * T)
{
intdata max = intarray_get(T, 0);
for(int i = 1; i < intarray_lenght(T); i++)
if (intarray_get(T, i) > max)
max = intarray_get(T, i);
return max;
}
/*--------------------------------------------------------------------------------------------------------------*/
/*--------------------------------------------------------------------------------------------------------------*/
intarray * intarray_clone(intarray * T)
{
intarray * clone = intarray_create(intarray_lenght(T));
for(int i = 0; i < intarray_lenght(T); i++)
{
clone->data[i] = intarray_get(T, i);
}
return clone;
}
/*--------------------------------------------------------------------------------------------------------------*/
/*--------------------------------------------------------------------------------------------------------------*/
float intarray_median(intarray * T)
{
// On copie les valeurs du tableau dans un clone
intarray * clone = intarray_clone(T);
intarray_sort(clone);
// On utilise une variable pour desalouer la copie
float r;
if(intarray_lenght(clone) % 2 == 1)
r = clone->data[intarray_lenght(clone) / 2];
else
{
float val1 = clone->data [ (intarray_lenght(clone) - 1) / 2 ];
float val2 = clone->data [ (intarray_lenght(clone) + 1) / 2 ];
r = (val1 + val2) / 2;
}
intarray_destroy(clone);
return r;
}
/*--------------------------------------------------------------------------------------------------------------*/
/*--------------------------------------------------------------------------------------------------------------*/
float intarray_average(intarray * T)
{
int sum = intarray_sum(T);
return sum / intarray_lenght(T);
}
/*--------------------------------------------------------------------------------------------------------------*/
/*--------------------------------------------------------------------------------------------------------------*/
void intarray_add(intarray * T, intdata n)
{
/*
assert (T->len < T->alloc);
T->data[T->len] = n;
T->len++;
*/
intarray_set_ext(T, T->len, n);
}
/*--------------------------------------------------------------------------------------------------------------*/
/*--------------------------------------------------------------------------------------------------------------*/
void intarray_delete(intarray * T, int i)
{
assert(T->len > 0);
assert(i < T->len);
T->data[i] = T->data[T->len - 1];
T->len--;
}
/*--------------------------------------------------------------------------------------------------------------*/
/*--------------------------------------------------------------------------------------------------------------*/
intarray * intarray_empty_create(int alloc)
{
return intarray_create_ext(0, alloc);
}
/*--------------------------------------------------------------------------------------------------------------*/
/*--------------------------------------------------------------------------------------------------------------*/
void intarray_set_ext(intarray * T, int i, intdata n)
{
if(i >= T->alloc)
intarray_alloc_more(T, i * 2);
if(i >= T->len)
T->len = i + 1;
intarray_set(T, i, n);
}
/*--------------------------------------------------------------------------------------------------------------*/
/*--------------------------------------------------------------------------------------------------------------*/
void intarray_alloc_more(intarray * T, int new_alloc)
{
int * tmp = malloc(sizeof(*tmp) * new_alloc);
for(int i = 0; i < T->len ; i++)
tmp[i] = T->data[i];
free(T->data);
T->data = tmp;
T->alloc = new_alloc;
}
/*--------------------------------------------------------------------------------------------------------------*/Le fichier intarray.h ci dessous :
#define INTARRAY_DEFAULT_ALLOC 10
typedef int intdata; // Le type que je ne peux pas passer dans fichier tools.h
typedef struct _intarray
{
int * data;
int len;
int alloc;
} intarray;
extern intarray * intarray_standart_empty_create(void);
extern void intarray_delete(intarray * T, int i);
extern void intarray_add(intarray * T, intdata n);
extern intarray * intarray_create_ext(int len, int alloc);
extern void intarray_debug (intarray * T);
extern intarray * intarray_create(int len);
extern void intarray_destroy(intarray * T);
extern int intarray_get(intarray * T, int i);
extern void intarray_set(intarray * T, int i, intdata n);
extern void intarray_set_ext(intarray * T, int i, intdata n);
extern int intarray_lenght(intarray * T);
extern int intarray_get_min(intarray * T);
extern intarray * intarray_concate(intarray * T1, intarray * T2);
extern int intarray_get_min_index(intarray * T, int start);
extern void intarray_sort(intarray * T);
extern int intarray_sum(intarray * T);
extern float intarray_average(intarray * T);
extern float intarray_median(intarray * T);
extern int intarray_get_max(intarray * T);
extern intarray * intarray_clone(intarray * T);
extern intarray * intarray_empty_create(int alloc);
extern void intarray_alloc_more(intarray * T, int new_alloc);Le fichier tools.c ci dessous :
#include "tools.h"
#include <assert.h>
/*-----------------------------------------------------------------------------------------*/
int string_to_int(char * ch)
{
int r = 0;
for(int i = 0; ch[i] != 0; i++)
{
assert ((ch[i] >= '0') && (ch[i] <= '9'));
r *= 10;
r += ((int) ch[i] - 48);
}
return r;
}
/*-----------------------------------------------------------------------------------------*/
/*-----------------------------------------------------------------------------------------*/
void int_swap(int* n, int* m)
{
int tmp;
tmp = (*n);
(*n) = (*m);
(*m) = tmp;
}
/*-----------------------------------------------------------------------------------------*/
/*-----------------------------------------------------------------------------------------*/
void char_swap(char * n, char * m)
{
char tmp;
tmp = (*n);
(*n) = (*m);
(*m) = tmp;
}
/*-----------------------------------------------------------------------------------------*/Le fichier tools.h ci dessous :
#define RC printf("\n")
typedef char * regstr;
extern int string_to_int(char * ch);
extern void int_swap(int * n, int * m);
extern void char_swap(char * n, char * m);Je comprends qu'on ne peut pas déplacer les nouveaux type chardata et intdata dans le fichier tools.h,
car sinon dans les prototypes des fonctions des fichiers intarray.h et jstr.h le compilateur me dit chardata et intdata type inconnu.
Et pourtant lui il y arrive. Es ce que quelqu'un à une explication ?
Dernière modification par zephyre123 (Le 04/05/2020, à 00:30)
Hors ligne
#2 Le 03/05/2020, à 23:50
- NicoApi73
Re : Aide message d'erreur du compilateur [RESOLU]
Bonsoir,
Pourquoi ça fonctionne chez lui et pas chez toi :
il a dans intarray.c
#include "tools.h"
]#include "intarray.h"Tu as
#include "intarray.h"
#include "tools.h"Je te déconseille très fortement de jouer sur l'ordre des headers pour que ça compile
Dernière modification par NicoApi73 (Le 03/05/2020, à 23:54)
Hors ligne
#3 Le 04/05/2020, à 00:12
- zephyre123
Re : Aide message d'erreur du compilateur [RESOLU]
Mais concrètement ça change quoi l'ordre des headers ?
C'est vrai j'ai changer l'ordre et je n'ai plus aucune erreur de compilation maintenant cependant je ne comprends pas pourquoi pouvez vous m'expliquer pourquoi l'ordre des headers est si important ?
Je n'y prêtais pas attention avant.
Je ne savais pas que l'ordre des headers étaient important et je ne comprends pas pourquoi ça l'ai.
Dernière modification par zephyre123 (Le 04/05/2020, à 00:29)
Hors ligne
#4 Le 04/05/2020, à 00:24
- NicoApi73
Re : Aide message d'erreur du compilateur [RESOLU]
zephyre123 a écrit :
Mais concrètement ça change quoi l'ordre des headers ?
Le moment où sont faites tes déclarations. Comme tu utiises le type intdata dans intarray.h, il faut qu'il soit déclaré avant...
Hors ligne
#5 Le 04/05/2020, à 00:30
- zephyre123
Re : Aide message d'erreur du compilateur [RESOLU]
ha ok merci pour ces précisions je comprends mieux maintenant.
Hors ligne