Ne rentre pas dans le if !?

Version imprimable

Bonjour,

J'ai codé un programme simple qui génére un nombre compris entre 0 et 9. Suivant que le nombre est pair ou impaire, il va récupérer dans un tableau ALPHABET ou NUMERIQUE une valeur pour le copier dans ID pour le moment. Sauf que le programme en rentre pas tout le temps dans la boucle de test.

Voici le code

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

Code:

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
 
int main (void)
{
 
 
     char ALPHABET[]={'A','B','C','E','F','G','H','I','J','K'};
     char NUMERIQUE[]={'0','1','2','3','4','5','6','7','8','9'};
 
     int taille=sizeof(ALPHABET)/sizeof(char);
     printf("\ntaille : %d\n", taille);
 
     char *ID=malloc(taille*sizeof(char));
     char *PW=malloc(taille*sizeof(char));
 
     FILE *OUT=fopen("out.txt","w");
 
     int i=0;
     for ( i=0 ; i<10 ; i++ )
         {  
            int temp;
            int mtemp;
 
            sleep(2000);
            temp=rand()%10;
            mtemp=temp%2;
 
 
            printf("_______________________________________________\n");
            printf("\ntemp :%d | mtemp : %d \n", temp, mtemp);
 
            if ( temp==0%2 )
               {
               printf("\npaire et ID[%d]=ALPHABET[%d]=%c\n", i, temp, ALPHABET[temp]);
               ID[i]=ALPHABET[temp];
               }
 
            if ( temp==1%2 )
               {
               printf("\nimpaire et ID[%d]=NUMERIQUE[%d]=%c\n", i, temp, NUMERIQUE[temp]);
               ID[i]=NUMERIQUE[temp];
               }
 
         }
 
    printf("\n");
 
                   int j=0;
     for ( j=0 ; j<10 ; j++ )
         {
               printf("%c",ID[j]);
         }
 
   // printf("\n");
//         
//              int k=0;
//     for ( k=0 ; k<10 ; k++ )
//         {
//               printf("%c",PW[k]);
//         }
 
 
 
 
 
 
 
     getch();    
     fprintf(OUT,"\nID:%s\nPW:%s", ID, PW);
 
 
}

Voici un screenshot

http://zepload.com/images/1240689472_Sans titre.jpg

Comme vous pouvez le constater, bien que la valeur mtemp (modulo temp) calculé à partir du modulo de temp soit correctement calculée, on voit bien que le programme ne rentre pas tout le temps dans la boucle de test. Je pensais que le programme allait trop vite ou je ne sais quoi alors j'ai mis une tempo mais cela ne change rien !

Merci d'avance.

25/04/2009, 23h09
gl

Citation:

Envoyé par darkwall_37

Comme vous pouvez le constater, bien que la valeur mtemp (modulo temp) calculé à partir du modulo de temp soit correctement calculée, on voit bien que le programme ne rentre pas tout le temps dans la boucle de test. Je pensais que le programme allait trop vite ou je ne sais quoi alors j'ai mis une tempo mais cela ne change rien !

Il rentre dans un des if si temp vaut 0 ou 1. En effet temp==0%2 est equivalent a temp==0 et temp=1%2 est equivalent ) temp==1.

Je suppose que tu souhaitais plutôt écrire (temp%2)==0 et (temp%2)==1 voire, puique la valeur est calculée, mtemp==0 et mtemp==1
25/04/2009, 23h09
darkwall_37

Réglé.
25/04/2009, 23h18
jeroman
Premier soucis :
Code:

1 2 temp=rand()%10; mtemp=temp%2;
Le problème, c'est que si temp est pair, mtemp sera lui aussi pair, et que si temp est impair, mtemp sera lui aussi impair. Or, d'après ce que je comprends de tes if, tu sembles vouloir utiliser le tableau ALPHABET si temp est pair, et NUMERIQUE si temp est impaire.
Donc :
* si temp est pair, seuls les indices pairs du tableau ALPHABET seront utilisés.
* si temp est impair, seuls les indices impairs du tableau NUMERIQUE seront utilisés.

En clair, les indices impaires de ALPHABET ne seront jamais utilisés et les indices pairs de NUMERIQUE ne seront jamais utilisés.

Second soucis :
Code:

1 2 if ( temp==0%2 ) if ( temp==1%2 )
L'opérateur modulo a la priorité sur l'opérateur d'égalité.
0 modulo 2 est égal à 0.
1 modulo 2 est égal à 1.
Là, tes if ne seront parcourus que si temp est égal à 0 ou à 1. Huit fois sur 10, ils ne seront pas parcourus.

Ton opérateur modulo est mal placé.
mtemp n'était pas censé être utilisé pour cela ?
25/04/2009, 23h56
darkwall_37

non mais pour me permettre de comprendre l'erreur, ce qui a été le cas, en effet temp==0%2 ne fait pas le test que j'espérais donc j'ai remplacé temp par mtemp et 0%2 par 0 enfin bref ça marche, merci de ton aide.

Citation:

Envoyé par darkwall_37

J'ai codé un programme simple

Ton code est incomplet :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
 
 
-------------- Build: Debug in hello ---------------
 
Compiling: main.c
Linking console executable: bin\Debug\hello.exe
C:\dev\hello\main.c: In function `main':
C:\dev\hello\main.c:10: warning: implicit declaration of function `printf'
C:\dev\hello\main.c:12: warning: implicit declaration of function `malloc'
C:\dev\hello\main.c:12: warning: ISO C90 forbids mixed declarations and code
C:\dev\hello\main.c:15: error: `FILE' undeclared (first use in this function)
C:\dev\hello\main.c:15: error: (Each undeclared identifier is reported only once
C:\dev\hello\main.c:15: error: for each function it appears in.)
C:\dev\hello\main.c:15: error: `OUT' undeclared (first use in this function)
C:\dev\hello\main.c:15: warning: implicit declaration of function `fopen'
C:\dev\hello\main.c:17: warning: ISO C90 forbids mixed declarations and code
C:\dev\hello\main.c:23: warning: implicit declaration of function `sleep'
C:\dev\hello\main.c:24: warning: implicit declaration of function `rand'
C:\dev\hello\main.c:47: warning: ISO C90 forbids mixed declarations and code
C:\dev\hello\main.c:67: warning: implicit declaration of function `getch'
C:\dev\hello\main.c:68: warning: implicit declaration of function `fprintf'
Process terminated with status 1 (0 minutes, 0 seconds)
4 errors, 10 warnings

Ta condition de test est trop complexe. tu as tendance à écrire du code plus compliqué que nécessaire, et à oublier l'essentiel...

Ceci devrait fonctionner. Pour des résutats changeants, ajouer srand() avec time()...

http://emmanuel-delahaye.developpez....=Page7#LXXXVII

Code:

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
 
#include <stdio.h>
#include <stdlib.h>
 
int main (void)
{
   char ALPHABET[] = { 'A', 'B', 'C', 'E', 'F', 'G', 'H', 'I', 'J', 'K' };
   char NUMERIQUE[] = { '0', '1', '2', '3', '4', '5', '6', '7', '8', '9' };
   int taille = sizeof ALPHABET;
 
   printf ("\ntaille : %d\n", taille);
 
   {
      char *ID = malloc (taille);
      if (ID != NULL)
      {
         char *PW = malloc (taille);
         if (PW != NULL)
         {
            FILE *fp_out = fopen ("out.txt", "w");
            if (fp_out != NULL)
            {
               int i = 0;
               for (i = 0; i < 10; i++)
               {
                int  temp = rand () % 10;
                 int mtemp = temp % 2;
 
                  printf
                     ("-------------------------------------------\n");
                  printf ("\ntemp :%d | mtemp : %d \n", temp, mtemp);
 
                  if (temp == 0)
                  {
                     printf ("\npaire et ID[%d]=ALPHABET[%d]=%c\n", i, temp,
                             ALPHABET[temp]);
                     ID[i] = ALPHABET[temp];
                  }
                  else
                  {
                     printf ("\nimpaire et ID[%d]=NUMERIQUE[%d]=%c\n", i,
                             temp, NUMERIQUE[temp]);
                     ID[i] = NUMERIQUE[temp];
                  }
               }
 
               printf ("\n");
 
               {
                  int j = 0;
                  for (j = 0; j < 10; j++)
                  {
                     printf ("%c", ID[j]);
                  }
               }
 
               printf ("\n");
#if 0
               {
                  int k = 0;
                  for (k = 0; k < 10; k++)
                  {
                     printf ("%c", PW[k]);
                  }
               }
#endif
               fprintf (fp_out, "ID:%s\nPW:%s\n", ID, PW);
               fclose (fp_out);
            }
            free (PW);
         }
         free (ID);
      }
   }
   return 0;
}

Code:

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
 
 
taille : 10
-------------------------------------------
 
temp :1 | mtemp : 1
 
impaire et ID[0]=NUMERIQUE[1]=1
-------------------------------------------
 
temp :7 | mtemp : 1
 
impaire et ID[1]=NUMERIQUE[7]=7
-------------------------------------------
 
temp :4 | mtemp : 0
 
impaire et ID[2]=NUMERIQUE[4]=4
-------------------------------------------
 
temp :0 | mtemp : 0
 
paire et ID[3]=ALPHABET[0]=A
-------------------------------------------
 
temp :9 | mtemp : 1
 
impaire et ID[4]=NUMERIQUE[9]=9
-------------------------------------------
 
temp :4 | mtemp : 0
 
impaire et ID[5]=NUMERIQUE[4]=4
-------------------------------------------
 
temp :8 | mtemp : 0
 
impaire et ID[6]=NUMERIQUE[8]=8
-------------------------------------------
 
temp :8 | mtemp : 0
 
impaire et ID[7]=NUMERIQUE[8]=8
-------------------------------------------
 
temp :2 | mtemp : 0
 
impaire et ID[8]=NUMERIQUE[2]=2
-------------------------------------------
 
temp :4 | mtemp : 0
 
impaire et ID[9]=NUMERIQUE[4]=4
 
174A948824
 
Process returned 0 (0x0)   execution time : 0.105 s
Press any key to continue.

Merci pour les précisions.

J'avais continué de mon côté,

Code:

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
107
108
109
110
111
112
113
114
#include <stdlib.h>
#include <stdio.h>
#include <time.h>
 
// PROTOTYPES //////////////////////////////////////////////////////////////////////////////////////////////////////
char *genere   ( char *chaine, int taille, char *ALPHABET, char *NUMERIQUE );
void  affichage( char *chaine, int taille                                  );
 
 
// FONCTION PRINCIPALES ////////////////////////////////////////////////////////////////////////////////////////////
int main (void)
{
 
     // NOM DE L'APPLICATION POUR LAQUELLE ON GENERE ID ET PW
     char NAME[1024];
     char CMD[1024];
 
     // TABLEAU DES CARACTERES GENRABLES
     char ALPHABET [] = {'A','B','C','E','F','G','H','I','J','K'};
     char NUMERIQUE[] = {'0','1','2','3','4','5','6','7','8','9'};
 
     // TAILLE DES DEUX TABLEAUX POUR L'ALLOCATION
     int taille=sizeof(ALPHABET)/sizeof(char);
 
     // ALLOCATION DYNAMIQUE EN MEMOIRE
     char *ID_vierge = malloc( taille*sizeof(char) );
     char *PW_vierge = malloc( taille*sizeof(char) );
     char *ID        = malloc( taille*sizeof(char) );
     char *PW        = malloc( taille*sizeof(char) );
 
     // FICHIER DE SORTIE POUR SAUVEGARDER L'ID ET LE PW GENERÉ
     FILE *OUT=fopen("out","w");
     //
 
     // FONCTION DE GENERATION;
     ID = genere( ID_vierge, taille, ALPHABET, NUMERIQUE );
     PW = genere( PW_vierge, taille, ALPHABET, NUMERIQUE );
 
     // INTERFACE
     system(" title GENERATEUR D'ID ET PW ");
     system(" MODE CON cols=100 lines=6 ");
     system(" color 09 ");
     printf("\n Nom de l'application pour laquelle vous souhaitez generer ID et PW : ");
     gets(NAME);
 
     // POUR RENOMER LE FICHIER
     sprintf(CMD,"ren out %s",NAME);
 
     // AFFICHAGE DE L'ID ET DU PW
     printf("\n ID : ");
     affichage( ID, taille );
     printf(" PW : ");
     affichage( PW, taille ); 
 
     // SAUVEGARDE DU FICHIER
     fprintf(OUT,"\nNOM:%s\nID:%s\nPW:%s", NAME, ID, PW);
 
     // FERMETURE ET DESALLOCATION
     fclose(OUT);
     free(ID);
     free(PW);
 
     // NOM DU FICHIER
     system(CMD);
 
     getch();  
}
 
// FONCTIONS //////////////////////////////////////////////////////////////////////////////////////////////////////////////
char *genere( char *chaine, int taille, char *ALPHABET, char *NUMERIQUE )
{
 
     int i=0;
     for ( i=0 ; i<10 ; i++ )
         {  
            int temp;
            int modulo;
 
            // GENERATION DU CHIFFRE ALEATOIRE
            temp=rand()%taille;
            modulo=temp%2;
 
            // CHOIX CARACTERE
            if ( modulo==0 )
               {
                   chaine[i]=ALPHABET[temp];
               }
 
            if ( modulo==1 )
               {
                   chaine[i]=NUMERIQUE[temp];
               }
 
         }
 
         return chaine;
 
}
 
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 
void affichage( char *chaine, int taille )
{
 
     int j=0;
     for ( j=0 ; j<taille ; j++ )
         {
               printf("%c", chaine[j]);
         }
     printf("\n"); 
 
}
 
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

J'ai une erreur indéterminée comme d'hab. Le code est correctement généré. Cependant une fois enregistré via le fprintf j'ai des caractères en trop !

Du genre j'obtiens

NOM:bonjour
ID:17FA9FJJCF\Bin;GI“r+Hå
PW:5517115C7Hws\sysI“r+Hå

au lieu de

NOM:bonjour
ID:17FA9FJJCF
PW:5517115C7H

Qu'est ce que j'ai encore bien pu faire :D ? merci et je vais regarder pour srand, il est vrai que les séquences générées sont toujours les mêmes.

26/04/2009, 00h53
Emmanuel Delahaye
Citation:
Envoyé par darkwall_37

J'ai une erreur indéterminée comme d'hab. Le code est correctement généré. Cependant une fois enregistré via le fprintf j'ai des caractères en trop !

Du genre j'obtiens

Code:

1 2 3 4 NOM:bonjour ID:17FA9FJJCF\Bin;GI“r+Hå PW:5517115C7Hws\sysI“r+Hå

au lieu de

Code:

1 2 3 4 NOM:bonjour ID:17FA9FJJCF PW:5517115C7H

Qu'est ce que j'ai encore bien pu faire :D ? merci et je vais regarder pour srand, il est vrai que les séquences générées sont toujours les mêmes.
Tu as probablement oublié qu'une chaine était terminée par un 0...

Code:

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
107
108
109
110
111
112
113
114
115
116
#include <stdlib.h>
#include <stdio.h>
#include <time.h>
 
// PROTOTYPES //////////////////////////////////////////////////////////////////////////////////////////////////////
char *genere   ( char *chaine, int taille, char *ALPHABET, char *NUMERIQUE );
void  affichage( char *chaine, int taille                                  );
 
 
// FONCTION PRINCIPALES ////////////////////////////////////////////////////////////////////////////////////////////
int main (void)
{
 
     // NOM DE L'APPLICATION POUR LAQUELLE ON GENERE ID ET PW
     char NAME[1024];
     char CMD[1024];
 
     // TABLEAU DES CARACTERES GENRABLES
     char ALPHABET [] = {'A','B','C','E','F','G','H','I','J','K'};
     char NUMERIQUE[] = {'0','1','2','3','4','5','6','7','8','9'};
 
     // TAILLE DES DEUX TABLEAUX POUR L'ALLOCATION
     int taille=sizeof(ALPHABET)/sizeof(char);
 
     // ALLOCATION DYNAMIQUE EN MEMOIRE
     char *ID_vierge = malloc( taille*sizeof(char) );
     char *PW_vierge = malloc( taille*sizeof(char) );
     char *ID        = malloc( taille*sizeof(char) );
     char *PW        = malloc( taille*sizeof(char) );
 
     // FICHIER DE SORTIE POUR SAUVEGARDER L'ID ET LE PW GENERÉ
     FILE *OUT=fopen("out","w");
     //
 
     // FONCTION DE GENERATION;
     ID = genere( ID_vierge, taille, ALPHABET, NUMERIQUE );
     PW = genere( PW_vierge, taille, ALPHABET, NUMERIQUE );
 
     // INTERFACE
     system(" title GENERATEUR D'ID ET PW ");
     system(" MODE CON cols=100 lines=6 ");
     system(" color 09 ");
     printf("\n Nom de l'application pour laquelle vous souhaitez generer ID et PW : ");
     gets(NAME);
 
     // POUR RENOMER LE FICHIER
     sprintf(CMD,"ren out %s",NAME);
 
     // AFFICHAGE DE L'ID ET DU PW
     printf("\n ID : ");
     affichage( ID, taille );
     printf(" PW : ");
     affichage( PW, taille ); 
 
     // SAUVEGARDE DU FICHIER
     fprintf(OUT,"\nNOM:%s\nID:%10s\nPW:%10s", NAME, ID, PW);
 
     // FERMETURE ET DESALLOCATION
     fclose(OUT);
     free(ID);
     free(PW);
 
     // NOM DU FICHIER
     system(CMD);
 
     getch();  
}
 
// FONCTIONS //////////////////////////////////////////////////////////////////////////////////////////////////////////////
char *genere( char *chaine, int taille, char *ALPHABET, char *NUMERIQUE )
{
 
     int i=0;
     for ( i=0 ; i<10 ; i++ )
         {  
            int temp;
            int modulo;
 
            // GENERATION DU CHIFFRE ALEATOIRE
            sleep(1000);
            srand(time(NULL));
            temp=rand()%taille;
            modulo=temp%2;
 
            // CHOIX CARACTERE
            if ( modulo==0 )
               {
                   chaine[i]=ALPHABET[temp];
               }
 
            if ( modulo==1 )
               {
                   chaine[i]=NUMERIQUE[temp];
               }
 
         }
 
         return chaine;
 
}
 
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 
void affichage( char *chaine, int taille )
{
 
     int j=0;
     for ( j=0 ; j<taille ; j++ )
         {
               printf("%c", chaine[j]);
         }
     printf("\n"); 
 
}
 
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

Voilà j'ai mis un srand, cependant cela de ne fait que décalé la chaine d'un cran vers la droite ou gauche d'un essai à l'autre. J'ai donc voulu insérer une tempo, mais elle ne marche pas non plus. Le programme met du temps à afficher la première ligne comme si la tempo s'effectuait à ce moment là puis après au moment de générer au lieu d'attendre 20*1s les codes générés apparaissent de suite ! Je comprends pas non plus. Pour le \0 il faudrait que j'effectue une troncature ou un truck du genre ?

Merci

26/04/2009, 01h15
darkwall_37

non mais en plus ce que je ne comprends pas c'est que pour bonjour je n'ai pas ce problème et de surcroit avant de faire les fonctions cela enregistrait correctement ID et PW via le fprintf !
26/04/2009, 03h23
Emmanuel Delahaye

Citation:

Envoyé par darkwall_37

Voilà j'ai mis un srand,

srand() ne doit être appelé qu'une fois. C'est expliqué dans l'article déjà cité. Il faut lire les informations complètement...

Pour le 0, il suffit d'écrire un 0 en fin de chaine, c'est tout. C'est du C élémentaire. Si tu as des doutes, relis tes cours de C au chapitre 'chaines'...

Oui c'est pas faux ! donc j'ai rajouté \0 à la fin de la chaine et maintenant ça marche, j'ai bougé le srand dans le main pour qu'il ne soit appelé qu'une fois et voilà maintenant ça fonctionne parfaitement bien.

Merci pour le temps accordé !

Code:

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
107
108
109
110
111
112
113
114
115
116
117
118
119
120
#include <stdlib.h>
#include <stdio.h>
#include <time.h>
 
// PROTOTYPES //////////////////////////////////////////////////////////////////////////////////////////////////////
char *genere   ( char *chaine, int taille, char *ALPHABET, char *NUMERIQUE );
void  affichage( char *chaine, int taille                                  );
 
 
// FONCTION PRINCIPALES ////////////////////////////////////////////////////////////////////////////////////////////
int main (void)
{
 
     // NOM DE L'APPLICATION POUR LAQUELLE ON GENERE ID ET PW
     char NAME[1024];
     char CMD[1024];
 
     // TABLEAU DES CARACTERES GENRABLES
     char ALPHABET [] = {'A','B','C','E','F','G','H','I','J','K'};
     char NUMERIQUE[] = {'0','1','2','3','4','5','6','7','8','9'};
 
     // TAILLE DES DEUX TABLEAUX POUR L'ALLOCATION
     int taille=sizeof(ALPHABET)/sizeof(char);
 
     // INITIALISATION DU TIMER
     srand(time(NULL));
 
     // ALLOCATION DYNAMIQUE EN MEMOIRE
     char *ID_vierge = malloc( taille*sizeof(char) );
     char *PW_vierge = malloc( taille*sizeof(char) );
     char *ID        = malloc( taille*sizeof(char) );
     char *PW        = malloc( taille*sizeof(char) );
 
     // FICHIER DE SORTIE POUR SAUVEGARDER L'ID ET LE PW GENERÉ
     FILE *OUT=fopen("out","w");
     //
 
     // FONCTION DE GENERATION;
     ID = genere( ID_vierge, taille, ALPHABET, NUMERIQUE );
     PW = genere( PW_vierge, taille, ALPHABET, NUMERIQUE );
 
     // INTERFACE
     system(" title GENERATEUR D'ID ET PW ");
     system(" MODE CON cols=100 lines=6 ");
     system(" color 09 ");
     printf("\n Nom de l'application pour laquelle vous souhaitez generer ID et PW : ");
     gets(NAME);
 
     // POUR RENOMER LE FICHIER
     sprintf(CMD,"ren out %s",NAME);
 
     // AFFICHAGE DE L'ID ET DU PW
     printf("\n ID : ");
     affichage( ID, taille );
     printf(" PW : ");
     affichage( PW, taille ); 
 
     // SAUVEGARDE DU FICHIER
     fprintf(OUT,"\nNOM:%s\nID:%9s\nPW:%9s", NAME, ID, PW);
 
     // FERMETURE ET DESALLOCATION
     fclose(OUT);
     free(ID);
     free(PW);
 
     // NOM DU FICHIER
     system(CMD);
 
     getch();  
}
 
// FONCTIONS //////////////////////////////////////////////////////////////////////////////////////////////////////////////
char *genere( char *chaine, int taille, char *ALPHABET, char *NUMERIQUE )
{
 
     int i=0;
     for ( i=0 ; i<taille ; i++ )
         {  
            int temp;
            int modulo;
 
            // GENERATION DU CHIFFRE ALEATOIRE
 
            temp=rand()%taille;
            modulo=temp%2;
 
            // CHOIX CARACTERE
            if ( modulo==0 )
               {
                   chaine[i]=ALPHABET[temp];
               }
 
            if ( modulo==1 )
               {
                   chaine[i]=NUMERIQUE[temp];
               }
 
         }
 
         chaine[taille]='\0';
 
         return chaine;
 
}
 
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 
void affichage( char *chaine, int taille )
{
 
     int j=0;
     for ( j=0 ; j<taille ; j++ )
         {
               printf("%c", chaine[j]);
         }
     printf("\n"); 
 
}
 
/////////

////////////////////////////////////////////////////////////////////////////////////////////////////////////