Ubuntu-fr

zephyre123

problème de dépendance mais je ne vois pas ou [RESOLU]

Bonjour,

J'ai une erreur incompréhensible de la part de ma commande make.
Je pense qu'il s'agit d'une erreur de dépendance cependant je ne vois pas ou.
Tout ce que je sais c'est que l'erreur se situe dans le fichier intarray.c pourtant j'ai bien inclus les deux dépendances intarray.h et tools.h dedans.
Ci dessous tous les fichiers :
intarray.c

#include <stdio.h>
#include <stdlib.h>
#include <assert.h>

#include "intarray.h"
#include "tools.h"

// Cette fonction affiche les cases du tableau
//-------------------------------------------
void intarray_debug (intarray T)
{
	for (int i = 0; i < T.len; i++)
		printf("%d ", T.data[i]);
}
//-------------------------------------------

// Cette fonction crée un tableau d'entier de taille len
//-------------------------------------------
intarray intarray_create(int len)
{
	intarray A;
	A.len = len;
	A.data = malloc(sizeof(int) * len);
	return A;
}
//-------------------------------------------

// Cette fonction libere la mémoire du tableau
//-------------------------------------------
void intarray_destroy(intarray T)
{
	free(T.data);
}

//-------------------------------------------

// Cette fonction permet d'obtenir la valeur de la i-eme case du tableau
//-------------------------------------------
int intarray_get(intarray T, int i)
{
	assert (i >= 0);
	assert (i < T.len);
	return T.data[i];
}

//-------------------------------------------

// Cette fonction associe la valeur n à la i-eme case du tableau
//-------------------------------------------
void intarray_set(intarray T, int i, int n)
{
	T.data[i] = n;

}
//-------------------------------------------

// Cette fonction retourne la taille du tableau
//-------------------------------------------
int intarray_lenght(intarray T)
{
	return T.len;

}
//-------------------------------------------

// Cette fonction retourne la valeur minimum du tableau
//-------------------------------------------
int intarray_get_min(intarray T)
{
	int 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;
}
//-------------------------------------------

// Cette fonction concatene deux tableaux
//-------------------------------------------
intarray intarray_concate(intarray T1, intarray T2)
{
	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;

}
//-------------------------------------------
// Cette fonction echange la valeur de deux entiers
//-------------------------------------------
void swap(int* n, int* m)
{
	int tmp;
	tmp = (*n);
	(*n) = (*m);
	(*m) = tmp;
}
//-------------------------------------------

// Cette fonction retourne l'indice du minimum du tableau a partir de la n-ieme case
//-------------------------------------------
int intarray_get_min_index(intarray T, int start)
{
	// Initialisation du min et de l'indice min 
	int 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;
}
//-------------------------------------------

// Cette fonction trie un tableau dans l'ordre croissant par valeur minimale
//-------------------------------------------
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);
		swap(&(T.data[index_min]), &(T.data[i]));
	}
}
//-------------------------------------------

// Cette fonction calcule la somme des entiers contenu dans le tableau
//-------------------------------------------
int intarray_sum(intarray T)
{
	int somme = 0;

	for(int i = 0; i < intarray_lenght(T); i++)
		somme += T.data[i];

	return somme;
}
//-------------------------------------------

// Cette fonction donne la moyenne du tableau
//------------------------------------------
float intarray_midle(intarray T)
{
	float somme  = intarray_sum(T);
	return (somme / intarray_lenght(T));

}
//-------------------------------------------

// Cette fonction retourne la valeur maximum du tableau
//-------------------------------------------
int intarray_get_max(intarray T)
{
	int 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;
}
//-------------------------------------------

// Cette fonction copie le tableau passé en parametre
//-------------------------------------------
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;
}
//-------------------------------------------

// Cette fonction retourne la mediane du tableau
//-------------------------------------------
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;
}

intarray.h :

typedef struct _intarray
{
	int* data;
	int len;

} intarray;

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, int n);
extern int intarray_lenght(intarray T);
extern int intarray_get_min(intarray T);
extern intarray intarray_concate(intarray T1, intarray T2);
extern void swap(int* n, int* m);
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 float intarray_midle(intarray T);

tools.c :

#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;
}

tools.h

#define RC printf("\n")
extern int string_to_int(char* ch)

main.c

#include <stdio.h>
#include <stdlib.h>
#include <assert.h>

#include "intarray.h"
#include "tools.h"


int main(int argc, char* argv[])
{
	assert(argc >= 2);

	int taille = argc - 1; // On ne compte pas le premier argument qui est le nom du programme

	intarray T = intarray_create(taille);

	for(int i = 0; i < taille; i++)
		T.data[i] = string_to_int(argv[i + 1]);

	int min = intarray_get_min(T);
	int max = intarray_get_max(T);
	float average = intarray_average(T);
	float median = intarray_median(T);
	printf("Le minimum est : %d" min);
	RC;
	printf("Le maximum est : %d" max);
	RC;
	printf("La moyenne est : %f" average);
	RC;
	printf("La medianne est : %f", median);
	RC;

	return 0;
}

makefile

intarray.exe : intarray.o tools.o main.o
	gcc intarray.o main.o tools.o -o intarray.exe

intarray.o : intarray.c intarray.h tools.h
	gcc -c intarray.c

main.o : main.c intarray.h tools.h
	gcc -c main.c

tools.o : tools.c tools.h
	gcc -c tools.c

Dernière modification par zephyre123 (Le 17/04/2020, à 18:43)

grigouille

Re : problème de dépendance mais je ne vois pas ou [RESOLU]

tools.h : il manque le "point virgule" à la fin de la ligne.

---

Debian (xfce) 12
HP LaserJet M1132 MFP

zephyre123

Re : problème de dépendance mais je ne vois pas ou [RESOLU]

merci grigouille ça fonctionne maintenant il reste juste une petite erreur c'est que la fonction intarray_average n'est pas définis dans le fichier intarray.c
d'après gcc.

Dernière modification par zephyre123 (Le 17/04/2020, à 18:36)