Discussion :

[PKO06]

Bonjour,

Je dois réaliser un petit projet.
Il faut créer et maintenir ordonnée un tableau d'identifiant alpha-numériques.
Le nom du tableau est table.
N est la taille max du tableau.

Je dois développer de façon modulaire ces fonctions :
- Saisie dans variable de nom buf
- Test demandant à l'utilisateur de continuer la saisie
- Contrôle de non dépassement de table
- Contrôle evitant la saisie de doublons
- recherche donnant la position dans la table
- Affichage du tableau

Je rencontre des difficultés sur l'architecture du projet, notamment les passages de paramètres et l'initialisation des variables.

Mon projet est composé de 3 fichiers :

util.h, fichiers d'entêtes

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
 
/* taille maximale du tableau, attention le nombre d'identifiant    **
** stockés sera de N-1, le tableau comportant un element final '\0' */
#define N 100
 
//Longueur maximale des chaines stockées dans le tableau	
#define L 20	
 
/* Fonction regroupant les méthodes permettant d'inserer **
** un identifiant dans la table				   */
int edition(char *** tab);
void visualisation(char** tab);
 
/* Fonction qui vide le flux d'entrée stdin, à utiliser si stdin **
** n'est pas lu en entier							 */
void viderFlxStdin(void);
 
//fonction de saisie dans une variable, pas plus de max caractères
char* saisie (size_t max, int *p_err);
//retourne 1 si la saisie continue
int testSaisie(char* buf);
//retourn 1 si taille non depassée
int ctrlTaille(char** table);
//retourne 1 si l'identifiant à inserer n'existe pas déjà
int ctrlDoublon(char** table, char* buf);
//retourne la position à laquelle l'identifiant doit être inseré
int position(char** table, char* buf);
//insertion effective dans le tableau
int insertion(char** table, char* buf, int pos);
//affichage du tableau
int affichage(void);

utils.c regroupant les fonctions à developper.
je ne suis pas très satisfait de ma fonction insertion effective :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
 
int insertion(char** table, char* buf, int pos){
 
	int i = 0;
	int j = 0;
 
	char** tabTmp = malloc(sizeof(table)+1);
	printf("dans insertion\n");
	/* allocation du bloc pour buf */
	tabTmp[pos] = (char*) malloc(sizeof(buf));
	/* copie de buf à sa position d'insertion */
	tabTmp[pos]= buf;
	printf("apres copie de buf a pos\n");
	/* recopie dans tabTmp des éléments de table dont la position **
	** est inferieur à pos                                        */
	for(i=0 ; i<pos ; i++){
		tabTmp[i] = (char*)malloc(sizeof(table[i]));
		tabTmp[i] = table[i];
	}
	printf("apres copie de avant pos\n");
	/* recopie dans tabTmp des éléments de table qui doivent être **
	** décalés d'une position après l'insertion de buf            */
	while(table[pos+j] != '\0'){
		tabTmp[pos+j+1] = (char*) malloc(sizeof(table[pos+j]));
		tabTmp[pos+j+1] = table[pos+j];
		j++;
	}
	printf("apres copie de apres pos\n");
	/* copie de '\0' à la fin de table pour indiquer la fin du tableau */
	tabTmp[pos+j+1] = (char*) malloc(1);
	tabTmp[pos+j+1] = '\0';
 
	free(table);
	table=tabTmp;
 
	printf("fin insertion\n");
 
	return 1;
}

Et enfin main.c. regroupant le menu et les méthodes edition et affichage.
Le passage de paramètres entre le main et édition me pose problème. Surtout pour le tableau, je ne sais pas si je dois (si c'est recommander ou non) le déclarer globalement. J'initialise le tableau avec '\0' pour reperer la fin.

un petit résumé de main.c

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
 
int main(int argc, char *argv[])
{
	/* le tableau d'identifiants */
	char** table = NULL;
 
	/* initialisation du tableau. '\0' et l'indication de fin du tableau */
	table = (char**)malloc(1);
	table[0] = (char*)malloc(1);
	table[0] = '\0';
 
     /* j'ai integré un menu et si l'on choisi d'ajouter un identifiant appel de
     la méthode edition */
     edition(&table);
}
//dans le meme fichier méthode édition
int edition(char *** table){
	/* Variable de nom buf pour la saisie de l'identifiant au clavier */
	char* buf = NULL;
	int err;
	int posInsertion;
 
	/* Saisie au clavier dans buf */
	buf = saisie (L, &err);		
 
	if (buf != NULL){
 
		/* saisie tronquée */
		if (err){
			/* vider le flux stdin */
			viderFlxStdin();
		}
 
		if(testSaisie(buf)){
			/* L'utilisateur souhaite continuer l'insertion */
 
			if(ctrlTaille(*table)){
				/* La table n'est pas pleine */
 
				if(ctrlDoublon(*table, buf)){	
					/* L'identifiant n'existe pas encore */	
					posInsertion = position(*table, buf);
					insertion(*table, buf, posInsertion);
					free(buf);
					return 1;
				}
				else{
					free(buf);
					return 0;
				}
 
			}
			else{
				free(buf);
				return 0;
			}
		}
		else{
			free(buf);
			return 0;
		}
	}
	else{
		return 0;
	}
}

J'éspere vous avez eu le courage d'arriver jusqu'ici
Vous avez du remarquer que j'utilise un tableau temporaire tabTmp que j'attribue ensuite à table. Je m'emmele totalement entre les passages des paramètre entre main, edition et insertion.
Revenu dans le main table semble être vide ... enfin l'est surement.

Je prend tout vos conseils, même si je dois revoir tout l'architecture, qui me semble bancale.

Merci

[PRomu@ld]

Juste deux choses :

Vérifies toujours les retours de malloc.
Oublies les cast sur les malloc, tu n'en as plus besoin depuis longtemps.

[Franck.H]

Juste deux choses :

Vérifies toujours les retours de malloc.
Oublies les cast sur les malloc, tu n'en as plus besoin depuis longtemps.

J'aurais dit Trois choses donc voici la dernière:

Tes tabulations sont monstrueuses ! Le code en deviens moins bien lisible avec des tabulations à 8 Entre 3 et 4 ca suffit largement

[zooro]

Je serais à ta place, j'utiliserais plutôt une structure à la place du tableau seul.
Par exemple:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
typedef struct {
   char** table;
   int nb_elements;
} tTableau;

nb_elements permet de se passer du '\0' que tu insères pour identifier la fin de la liste.

Ensuite, tu peux écrire un "constructeur" et un "destructeur" pour ce pseudo-objet, de façon à initialiser correctement la structure (table = NULL; nb_elements = 0), et à la libérer correctement (tous les elements du tableau, et remise à zéro des valeurs).

Pour la suite, il te suffira alors de passer l'adresse de cette struture à tes fonctions:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
int main(void)
{
   tTableau *table = NULL;
   (...)
   table = tableau_construct();
   if (table == NULL)
      exit(EXIT_FAILURE);
 
   edition(table);
   (...)
   tableau_destruct(table); 
   table = NULL;
   exit(EXIT_SUCCESS);
}

[PKO06]

Merci pour vos conseils. Je vais utiliser une structure.