Discussion :

[karioka78]

Je dois codé un programe en C pour créer un tableau d'identifiants alphanumériques. Il faut rentrer les identifiants de facon dynamique et en utilisant le tri par insertion avec la recherche dichotomique.

J'ai du mal avec la fonction Position Insertion si quelqu'un pouvait m'aider...je suis super novice en 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
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
#include <stdio.h>
#include <stdlib.h>
# define N 10
 
/* Déclaration des variables globales*/
char saisie[20+1]; /*Tableau de char pour la saisie*/
char* table[N][20]; /*Tableau des identifiants*/
 
void Presentation()
{
   /* Présentation du programme */
   printf("*******************************************\n");
   printf("* Tableau d'identifiants alpha-numeriques *\n");
   printf("*******************************************\n\n");
   /* Présentation du nb max d'identifiants */
   printf("Le nombre maximum d'identifiants est de %d\n\n", N);  
}
 
/*Saisie dans une variable de nom buf*/
void SaisieBuf()
{
   char buf[20+1];
   /* Demande de saisie de l'identifiant */
   printf("Veuillez entrer un identifiant :\n");
   /* Lecture de l'identifiant */
   scanf("%s",&buf);
   strcpy(saisie,buf);
   //printf("\n%s\n",saisie);
}
 
int TestUtilisateur()
{
   char rep[3];
   printf("Souhaitez-vous continuer la saisie ? oui / non \n");
   scanf("%s",&rep);
   if(strcmp(rep,"oui")==0) return 1;
   else {return 0;}
}
 
int NonDepassement(int TailleTab)
{
   if (TailleTab<N) return 1;
   else return 0;
}
 
void Insertion(int indice, int TailleTab)
{
   int j;
   for(j=indice;j<TailleTab;j++)
   {
      printf("%s \n",table[j]);        
      *table[j+1]=(char *)malloc(sizeof(table[j]));
      strcpy(*table[j+1],*table[j]);
   }
   *table[indice]=(char *)malloc(strlen(saisie));
   strcpy(*table[indice],saisie);
   free(saisie);
}
 
int PositionInsertion(char val[], int TailleTab)
{
   int gauche,droite,milieu;
   gauche=0;
   droite=TailleTab;
   while(gauche<droite)
   {
      milieu = (gauche+droite)/2;
      if(strcmp(val,table[milieu])<0) droite=milieu;
      else gauche=milieu;
   }
   return gauche;
}
 
void Affichage()
{
   int z;
   for(z=0;z<N;z++){printf("%s\n",*table[z]);}  
}
 
/*
void Doublon()
{}
*/
 
int main(int argc, char *argv[])
{
   int i=0;
   int indice;
   Presentation();
   while(NonDepassement(i)==1)
   {
      SaisieBuf();
      //printf("\n%s\n",saisie);
      indice=PositionInsertion(saisie,i);
      printf("\n%d\n",indice);
      i++;
      Insertion(indice,i);
      if(i>1)
      {
         if(TestUtilisateur()==0)break;
      }
   }
   Affichage();
   system("PAUSE");	
   return 0;
}

[Beldom]

Utilise la balise code (le # )! Et fait un effort d'indentation.

Là, c'est vraiment illisible, donc très compliqué de t'aider !

Edit : Mes commentaires au fur et à mesure :

Dans ton while, plutôt que de faire appel à une fonction, fait directement la comparaison.
Plutôt que deux if enchainé, utilise &&. De même, i == 0 équivaut à !i .
Voici un exemple possible (Je continue ma lecture au fur et à mesure)

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
int main(int argc, char *argv[])
{
    int i = 0;
    int indice;
 
    Presentation();
    while (i < N)            /* ICI, ne pas faire appel à une fonction pour une simple comparaison ! */
     {
         SaisieBuf();
         //printf("\n%s\n",saisie);
         indice = PositionInsertion(saisie,i);
         printf("\n%d\n",indice);
         i++;
         Insertion(indice,i);
         if (i > 1 && !TestUtilisateur())      /* Utilise un opérateur logique && plutôt que deux if d'affilée... */
              break;
     }
 
     Affichage();
     system("PAUSE"); /* Pourquoi ne pas utiliser pause() ? */
     return 0;
}

[aoyou]

Je pense que tu as déjà un souci dès la 7ème ligne

Code :

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

char* table[N][20];

Tu ne déclares pas un tableau d'identifiants mais une matrice d'identifiants.

Petite chose : quitte à faire un #define pour N pourquoi ne pas en faire un pour 20 aussi ?

[karioka78]

Merci et désolé pour la présentation.

Je vous ai pas menti je suis vraiment novice...

si je veux déclarer un tableau d'identifiants comment faire? J'ai vu des posts ou ils déclarent des tableaux à deux dimensions en faisant :

char **table[][]

a quoi servent les deux étoiles c'est des pointeurs de pointeurs..??

[Beldom]

En effet, ton problème viens de ce que tu déclares.

Tu veux un tableau de pointeur, donc char Tab[][] et pas char *Tab[][]...

Corrige ca et ta fonction devrait aller un peu mieux.

Par contre, tu as des enormes fuites de mémoire !
Et quand je dis enorme...

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
void Insertion(int indice, int TailleTab)
{
   int j;
   for(j=indice;j<TailleTab;j++)
   {
      printf("%s \n",table[j]);        
      *table[j+1]=(char *)malloc(sizeof(table[j]));
      strcpy(*table[j+1],*table[j]);
   }
   *table[indice]=(char *)malloc(strlen(saisie));
   strcpy(*table[indice],saisie);
   free(saisie);
}

Tu fais un nouveau malloc à chaque passage dans ta boucle, sans jamais free l'ancien...
Et en plus, tu me donne vraiment l'impression d'allouer n'importe comment, mais je n'en suis pas tout à fait certain...

En partant sur un principe de tableau de pointeur (Donc : char Tab[N][20 + 1]), qui devrait correspondre à tes besoins, et en partant de la fin pour aller vers l'indice qu'il te faut pour pouvoir free sans problème :

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
void Insertion(int indice, int TailleTab)
{
   int j;
   for (j =  TailleTab - 1; j >= indice; j--)
   {
      printf("%s \n",table[j]);   
      table[j + 1] = malloc(sizeof(table[j]) * strlen(table[j]));
      strcpy(table[j + 1], table[j]);
      free(table[j]);
   }
 
   table[indice] = malloc(sizeof(table[indice] * strlen(saisie));
   strcpy(table[indice], saisie);
 /*    free(saisie); */             /* saisie n'a jamais été malloc, il ne faut donc pas la free. C'est une variable globale déclarée en "dur". */
}

J'ai pas de quoi tester sous la main, mais ca devrait être plus correct selon moi, même si on inverse le sens. Ca évite les écrasements par erreur de données...
A vérifier donc, mais plus probable...

[karioka78]

Ok j'ai compri pour la mémoire j'avoue que ce qui parraissait logique pour moi ne l'est pas du tout en fait. Cependant il y a un problème lors le l'allocation :

Code :

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

table[j + 1] = malloc(sizeof(table[j]) * strlen(table[j]));

le compilateur me dit que les types sont incompatibles

[aoyou]

malloc retourne un pointeur que tu essaies d'affecter à un char[20]...

si tu as défini ton tableau ainsi (à préciser car on ne sait pas)

Code :

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

char table[N][20];

Tu n'as plus besoin d'allouer la mémoire (Table[i] contient un char[20])