Ubuntu-fr

zephyre123

programmation modulaire comment faire ? [RESOLU]

Bonjour,

J'aime bien programmer ça me passe le temps et ça développe ma logique.
Cependant pour bien faire les choses j'ai compris que le main.c ne devais servir que de test et que le programme devait être découpé dans des fonctions.
Et que ces fonctions elles mêmes devait être découpées dans des fichiers, chose que j'essaye de faire ici.
J'ai 3 fichiers :
- main.c
- intarray.c
- intarray.h

Le code de ces 3 fichiers est ci dessous :
main.c

#include <stdio.h>
#include <stdlib.h>
#include "intarray.h"
int main(void)
{
	intarray T1 = intarray_create(6);

	for(int i = 0; i < intarray_lenght(T1); i++)
		intarray_set(T1, i, i * 5);

	intarray_debug(T1);

	printf("\n");

	printf("Le minimum du tableau est %d\n", intarray_get_min(T1));

	intarray T2 = intarray_create(6);

	for(int i = 0; i < intarray_lenght(T2); i++)
		intarray_set(T2, i , 2 * i);

	intarray_debug(T2);

	printf("\n");

	intarray T = intarray_concate(T1, T2);

	intarray_debug(T);

	printf("\n");

	intarray_sort(T);

	intarray_debug(T);

	printf("\n");

	return 0;
}

intarray.c :

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


typedef struct _intarray
{
	int* data;
	int len;

} intarray;


// 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(4 * 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]));
	}
}

intarray.h :

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

typedef struct _intarray
{
	int* data;
	int len;

} intarray;


// Cette fonction affiche les cases du tableau
//-------------------------------------------
extern void intarray_debug (intarray T);
//-------------------------------------------

// Cette fonction crée un tableau d'entier de taille len
//-------------------------------------------
 extern intarray intarray_create(int len);
//-------------------------------------------

// Cette fonction libere la mémoire du tableau
//-------------------------------------------
 extern void intarray_destroy(intarray T);
//-------------------------------------------

// Cette fonction permet d'obtenir la valeur de la i-eme case du tableau
//-------------------------------------------
 extern int intarray_get(intarray T, int i);
//-------------------------------------------

// Cette fonction associe la valeur n à la i-eme case du tableau
//-------------------------------------------
 extern void intarray_set(intarray T, int i, int n);
//-------------------------------------------

// Cette fonction retourne la taille du tableau
//-------------------------------------------
 extern int intarray_lenght(intarray T);
//-------------------------------------------

// Cette fonction retourne la valeur minimum du tableau
//-------------------------------------------
 extern int intarray_get_min(intarray T);
//-------------------------------------------

// Cette fonction concatene deux tableaux
//-------------------------------------------
 extern intarray intarray_concate(intarray T1, intarray T2);
//-------------------------------------------

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

// Cette fonction retourne l'indice du minimum du tableau a partir de la n-ieme case
//-------------------------------------------
 extern int intarray_get_min_index(intarray T, int start);
//-------------------------------------------

// Cette fonction trie un tableau dans l'ordre croissant par valeur minimale
//-------------------------------------------
 extern void intarray_sort(intarray T);
//-------------------------------------------

J'ai bien inclue le fichier intarray.h dans le fichier intarray.c et le fichier main.c donc normalement je ne devrais pas avoir de problème.
Cependant le compilateur me remontre un nombre incalculable d'erreur lorsque j'essaye de généré le .objet du fichier intarray.c avec cette commande gcc -c intarray.c
Je ne sais pas d’où ces erreurs peuvent provenir je pensais avoir fait les choses dans les règles de l'art.
Je n'ai aucun souci pour générer le fichier main.o.
Pouvez vous m'aider svp

Dernière modification par zephyre123 (Le 11/04/2020, à 19:20)

pingouinux

Re : programmation modulaire comment faire ? [RESOLU]

Bonjour,
Le problème vient de ce que typedef struct _intarray apparaît à la fois dans intarray.c et dans intarray.h. intarray.c voit donc cette structure deux fois.

zephyre123

Re : programmation modulaire comment faire ? [RESOLU]

Merci pingouinux maintenant ça fonctionne