transformer de c++ à c

Version imprimable

comment je peut convertir un programme en c++, personnellement j'ai pas encore étudié c++, je ne sais que la programmation en C.
je cherche ici de l'aide pour le transformer en c.
voila le code

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
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
#include <iostream.h>
 #include <stdlib.h>
 #include <string.h>
 #include <conio.h>
 
 /*
 La valeur de chiffre ne doit pas dépasser la plage de valeur
 pour unsigned int càd 4 294 967 295 , sinon il y a erreur de
 conversion !!!
 */
 
 void ChiffreEnLettre(unsigned int, char*);
 int main()
 {
 unsigned int x = 0;
 char choix = 'o',c[256];
 while((choix=='o')||(choix=='O'))
 {
 cout << "Introduire un chiffre entier : ";
 cin >> x;
 ChiffreEnLettre(x,c);
 cout << "\nEn lettre ca fait : "<< c <<endl;
 cout << "\nEncore d'autre? (O/N): ";
 choix = getche();
 cout << "\n==================================================="<<endl;
 }
 return 0;
 }
 
 void ChiffreEnLettre(unsigned int chiffre, char * lettre)
 {
 unsigned int centaine, dizaine, unite, reste, y;
 bool dix = false;
 strcpy(lettre, "");
 reste = chiffre;
 for(int i=1000000000; i>=1; i/=1000)
 {
 y = reste/i;
 if(y!=0)
 {
 centaine = y/100;
 dizaine = (y - centaine*100)/10;
 unite = y-(centaine*100)-(dizaine*10);
 switch(centaine)
 {
 case 0:
 break;
 case 1:
 strcat(lettre,"cent ");
 break;
 case 2:
 if((dizaine == 0)&&(unite == 0)) strcat(lettre,"deux cents ");
 else strcat(lettre,"deux cent ");
 break;
 case 3:
 if((dizaine == 0)&&(unite == 0)) strcat(lettre,"trois cents ");
 else strcat(lettre,"trois cent ");
 break;
 case 4:
 if((dizaine == 0)&&(unite == 0)) strcat(lettre,"quatre cents ");
 else strcat(lettre,"quatre cent ");
 break;
 case 5:
 if((dizaine == 0)&&(unite == 0)) strcat(lettre,"cinq cents ");
 else strcat(lettre,"cinq cent ");
 break;
 case 6:
 if((dizaine == 0)&&(unite == 0)) strcat(lettre,"six cents ");
 else strcat(lettre,"six cent ");
 break;
 case 7:
 if((dizaine == 0)&&(unite == 0)) strcat(lettre,"sept cents ");
 else strcat(lettre,"sept cent ");
 break;
 case 8:
 if((dizaine == 0)&&(unite == 0)) strcat(lettre,"huit cents ");
 else strcat(lettre,"huit cent ");
 break;
 case 9:
 if((dizaine == 0)&&(unite == 0)) strcat(lettre,"neuf cents ");
 else strcat(lettre,"neuf cent ");
 }// endSwitch(centaine)
 
 switch(dizaine)
 {
 case 0:
 break;
 case 1:
 dix = true;
 break;
 case 2:
 strcat(lettre,"vingt ");
 break;
 case 3:
 strcat(lettre,"trente ");
 break;
 case 4:
 strcat(lettre,"quarante ");
 break;
 case 5:
 strcat(lettre,"cinquante ");
 break;
 case 6:
 strcat(lettre,"soixante ");
 break;
 case 7:
 dix = true;
 strcat(lettre,"soixante ");
 break;
 case 8:
 strcat(lettre,"quatre-vingt ");
 break;
 case 9:
 dix = true;
 strcat(lettre,"quatre-vingt ");
 } // endSwitch(dizaine)
 
 switch(unite)
 {
 case 0:
 if(dix) strcat(lettre,"dix ");
 break;
 case 1:
 if(dix) strcat(lettre,"onze ");
 else strcat(lettre,"un ");
 break;
 case 2:
 if(dix) strcat(lettre,"douze ");
 else strcat(lettre,"deux ");
 break;
 case 3:
 if(dix) strcat(lettre,"treize ");
 else strcat(lettre,"trois ");
 break;
 case 4:
 if(dix) strcat(lettre,"quatorze ");
 else strcat(lettre,"quatre ");
 break;
 case 5:
 if(dix) strcat(lettre,"quinze ");
 else strcat(lettre,"cinq ");
 break;
 case 6:
 if(dix) strcat(lettre,"seize ");
 else strcat(lettre,"six ");
 break;
 case 7:
 if(dix) strcat(lettre,"dix-sept ");
 else strcat(lettre,"sept ");
 break;
 case 8:
 if(dix) strcat(lettre,"dix-huit ");
 else strcat(lettre,"huit ");
 break;
 case 9:
 if(dix) strcat(lettre,"dix-neuf ");
 else strcat(lettre,"neuf ");
 } // endSwitch(unite)
 
 switch (i)
 {
 case 1000000000:
 if(y>1) strcat(lettre,"milliards ");
 else strcat(lettre,"milliard ");
 break;
 case 1000000:
 if(y>1) strcat(lettre,"millions ");
 else strcat(lettre,"million ");
 break;
 case 1000:
 strcat(lettre,"mille ");
 }
 } // end if(y!=0)
 reste -= y*i;
 dix = false;
 } // end for
 if(strlen(lettre)==0) strcpy(lettre,"zero");
 }

24/12/2009, 11h05
diogene

Il suffit de remplacer ce qui est purement C++ par l'équivalent en C :

1- cin et cout sont purement C++ : les remplacer par des scanf()/printf().
supprimer en conséquence l'include de <iostream.h> et le remplacer par celui de <stdio.h>

2- Ensuite, ça dépend si ton compilateur C supporte les booléens du C99. Si ce n'est pas le cas, remplacer tous les bool par int, les true par 1 et les false par 0.

3- Selon le compilateur C utilisé, tu peux avoir à déplacer certaines définitions de variables comme int i ici :

Code:

for(int i=1000000000; i>=1; i/=1000)

Le compilateur signalera les endroits où tu fois intervenir.

Ca devrait compiler ensuite.
24/12/2009, 11h08
fenrir

Bonjour,

Essaie voir les choses suivantes :
- Bien évidemment pour que ton projet soit effectivement en C, utilise un compilateur C au lieu de C++.
- En C, les fichiers sources sont de type *.c au lieu de *.cpp.
- La déclaration de ton main sera "int main(void)" ou "int main(int argc, char argv[])".
- En C, le type "bool" n'existe pas. De même que les valeurs "false" et "true". A la place on utilise un entier avec "faux = 0" et "vrai = !faux" (là tu peux faire un "#define FALSE" et un "#define TRUE").
- En C, <string.h> n'existe pas.
- Pour l'affichage et la saisie en C, on utilise <stdio.h> au lieu de <iostream.h> (et le <conio.h> m'a l'air inutile, mais à confirmer). Du coup, les cout et cin seront indéfinis et les opérateurs << et >> ne s'utilisent pas pour de l'affichage (décalage de bits, mais je doute que tu en es besoin ici :aie:). Voir ici pour l'utilisation des différentes fonctions d'affichage.

Si j'ai bien regardé ton code, je pense n'avoir rien oublié pour que ce que je te dise suffise. Regarde les FAQ et les tutos du site sur la partie C pour plus de précisions sur les modifications que je te propose ;). Commence ensuite à faire les opérations de changement nécessaires, si tu rencontres des problèmes reposte ici pour que les utilisateurs du forum t'aident à avancer.

Il y a bien sûr bien d'autres différences, et un cours sur ce site les présente dans la partie C++ : incompatibilité C et C++

Bon courage :ccool:.

EDIT : je me suis fait grillé :D. Et effectivement j'avais oublié le coup des déclaration des int dans une boucle for.
24/12/2009, 11h11
diogene

Citation:

- En C, <string.h> n'existe pas.

Si, c'est un fichier d'en tête standard.
24/12/2009, 11h14
fenrir

Merci de la précision :).
25/12/2009, 09h33
waldomania

Merci a tous.
28/12/2009, 14h51
waldomania

y'a t'il une autre methode pour remplacer le type booléen "dix"?
28/12/2009, 14h56
Pouet_forever

Utilise un int à la place ;)

Probleme d'affichage

Bonjour et merci pour votre aide,
finalement, j'ai réussi a convertir le programme mais j'ai rencontré un problème d'affichage: comment afficher la variable de sortie "lettre"?

voila mon code :

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
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
#include<stdio.h>
#include<string.h>
 
void main()
 {
 int centaine, dizaine, unite, reste, y,i,chiffre;
 char *lettre ;
 strcpy(lettre, "");
 reste = chiffre;
 printf("donner le chiffre");
 scanf("%d",&chiffre);
 
 
 for(i=1000000000; i>=1; i/=1000)
 {
 y = reste/i;
 if(y!=0)
 {
 centaine = y/100;
 dizaine = (y - centaine*100)/10;
 unite = y-(centaine*100)-(dizaine*10);
 switch(centaine)
 {
 case 0:
 break;
 case 1:
 strcat(lettre,"cent ");
 break;
 case 2:
 if((dizaine == 0)&&(unite == 0)) strcat(lettre,"deux cents ");
 else strcat(lettre,"deux cent ");
 break;
 case 3:
 if((dizaine == 0)&&(unite == 0)) strcat(lettre,"trois cents ");
 else strcat(lettre,"trois cent ");
 break;
 case 4:
 if((dizaine == 0)&&(unite == 0)) strcat(lettre,"quatre cents ");
 else strcat(lettre,"quatre cent ");
 break;
 case 5:
 if((dizaine == 0)&&(unite == 0)) strcat(lettre,"cinq cents ");
 else strcat(lettre,"cinq cent ");
 break;
 case 6:
 if((dizaine == 0)&&(unite == 0)) strcat(lettre,"six cents ");
 else strcat(lettre,"six cent ");
 break;
 case 7:
 if((dizaine == 0)&&(unite == 0)) strcat(lettre,"sept cents ");
 else strcat(lettre,"sept cent ");
 break;
 case 8:
 if((dizaine == 0)&&(unite == 0)) strcat(lettre,"huit cents ");
 else strcat(lettre,"huit cent ");
 break;
 case 9:
 if((dizaine == 0)&&(unite == 0)) strcat(lettre,"neuf cents ");
 else strcat(lettre,"neuf cent ");
 }// endSwitch(centaine)
 
 switch(dizaine)
 {
 case 0:
 break;
 case 1:
 if(unite=0) strcat(lettre,"dix");
 break;
 case 2:
 strcat(lettre,"vingt ");
 break;
 case 3:
 strcat(lettre,"trente ");
 break;
 case 4:
 strcat(lettre,"quarante ");
 break;
 case 5:
 strcat(lettre,"cinquante ");
 break;
 case 6:
 strcat(lettre,"soixante ");
 break;
 case 7:
 strcat (lettre,"soixante-dix ");
 break;
 case 8:
 strcat(lettre,"quatre-vingt ");
 break;
 case 9:
 strcat(lettre,"quatre-vingt-dix ");
 } // endSwitch(dizaine)
 
 switch(unite)
 {
 case 0:
 break;
 case 1:
 if(dizaine = 1) strcat(lettre,"onze ");
 else strcat(lettre,"un ");
 break;
 case 2:
 if(dizaine = 1) strcat(lettre,"douze ");
 else strcat(lettre,"deux ");
 break;
 case 3:
 if(dizaine = 1) strcat(lettre,"treize ");
 else strcat(lettre,"trois ");
 break;
 case 4:
 if(dizaine = 1) strcat(lettre,"quatorze ");
 else strcat(lettre,"quatre ");
 break;
 case 5:
 if(dizaine = 1) strcat(lettre,"quinze ");
 else strcat(lettre,"cinq ");
 break;
 case 6:
 if(dizaine = 1) strcat(lettre,"seize ");
 else strcat(lettre,"six ");
 break;
 case 7:
 if(dizaine = 1) strcat(lettre,"dix-sept ");
 else strcat(lettre,"sept ");
 break;
 case 8:
 if(dizaine = 1) strcat(lettre,"dix-huit ");
 else strcat(lettre,"huit ");
 break;
 case 9:
 if(dizaine = 1) strcat(lettre,"dix-neuf ");
 else strcat(lettre,"neuf ");
 } // endSwitch(unite)
 
 switch (i)
 {
 case 1000000000:
 if(y>1) strcat(lettre,"milliards ");
 else strcat(lettre,"milliard ");
 break;
 case 1000000:
 if(y>1) strcat(lettre,"millions ");
 else strcat(lettre,"million ");
 break;
 case 1000:
 strcat(lettre,"mille ");
 }
 } // end if(y!=0)
 reste -= y*i;
 } // end for
 //if(strlen(lettre)==0) strcpy(lettre,"zero");
 
 printf("le nobre est %s\n ",lettre);
 
 }

en plus j'ai une petite question pourqou en a utilisé un pointeur pour

Code:

char *lettre;

merci d'avance.

29/12/2009, 15h52
diogene
Citation:

en plus j'ai une petite question pourqou en a utilisé un pointeur pour

Code:

char *lettre;

C'est une erreur grave : lettre DOIT être un tableau, pas un pointeur
Code:

1 2 3 4 .... char lettre[256] ;// ou une taille suffisante pour stocker toute la chaine strcpy(lettre, ""); ....
29/12/2009, 16h29
waldomania

oui t'as raison.Merci
mais le programme n'est pas fonctionnel et y'a pas d'erreur de tout en plus j'ai une doute pour

Code:

printf("le nombre est : %s\n ",lettre);

printf("le nombre est : %s\n ",lettre); n'affiche rien. C'est sans doute parce qu'il n'y a rien dans lettre.
29/12/2009, 16h40
diogene

Avec une erreur de ce type (confusion tableau/pointeur) tu écrases, en essayant de stocker tes caractères, des données du programme et son comportement est indéfini. On peut considérer le programme comme détruit.

Il faut donc corriger cette erreur avant de s'étonner de quoi que ce soit d'anormal dans le déroulement du programme
30/12/2009, 10h10
waldomania
n'oublier pas que je n'ai converti un programme de c++ en c le principe est correct juste une petite modification.

ok je vais converti ligne par ligne et on verra.

petit question
role de :

Code:

void ChiffreEnLettre(unsigned int chiffre, char * lettre)

quest ce que ça veut dire (char * lettre)?

je crois qu'il a utilisé ici 2 fonction l'une à l'iterieur de l'autre
Code:

1 2 void ChiffreEnLettre(unsigned int, char*); int main()
qu'est ce qu'elle signifie?

Salut.

void main () n'est pas correcte.

Sinon, j'ai transformé ton code et il a l'air de marcher :

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
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
 
# define TRUE 1
# define FALSE 0
 
void clean_stdin (void) /* Procédure pour vider le buffer */
{
    int c = 0;
    do
    {
        c = getchar();
 
    } while (c != '\n' && c != EOF);
}
 
void ChiffreEnLettre(unsigned int, char*);
 
int main(void) /* Syntaxe correcte */
{
    unsigned x = 0;
    char choix = 'o', c[256];
    while((choix=='o')||(choix=='O'))
    {
        printf ("Introduire un chiffre entier : ");
        scanf ("%u", &x); /* bon format pour les unsigned */
        ChiffreEnLettre(x,c);
        printf ("\nEn lettre ca fait : %s", c);
        printf ("\nEncore d'autre? (O/N): ");
        clean_stdin ();/* on vide le buffer */
        choix = getchar (); /* Il t'es possible d'utiliser getch () si tu le souhaites (avec conio.h toujours), je l'ai remplacé pour la portabilité */
        printf("\n===================================================\n");
    }
    return 0;
 }
 
/* Une bonne identation est correcte pour relire le code */
 void ChiffreEnLettre(unsigned int chiffre, char * lettre)
 {
    unsigned int centaine, dizaine, unite, reste, y;
    int dix = FALSE, i = 0;
    strcpy(lettre, "");
    reste = chiffre;
    for(i=1000000000; i>=1; i/=1000)
    {
        y = reste/i;
        if(y!=0)
        {
            centaine = y/100;
            dizaine = (y - centaine*100)/10;
            unite = y-(centaine*100)-(dizaine*10);
            switch(centaine)
            {
                case 0: /* Oo */
                    break;
                case 1:
                    strcat(lettre,"cent ");
                    break;
                case 2:
                    if((dizaine == 0)&&(unite == 0))
                        strcat(lettre,"deux cents ");
                    else
                        strcat(lettre,"deux cent ");
                    break;
                case 3:
                    if((dizaine == 0)&&(unite == 0))
                        strcat(lettre,"trois cents ");
                    else
                        strcat(lettre,"trois cent ");
                    break;
                case 4:
                    if((dizaine == 0)&&(unite == 0))
                        strcat(lettre,"quatre cents ");
                    else
                        strcat(lettre,"quatre cent ");
                    break;
                case 5:
                    if((dizaine == 0)&&(unite == 0))
                        strcat(lettre,"cinq cents ");
                    else
                        strcat(lettre,"cinq cent ");
                    break;
                case 6:
                    if((dizaine == 0)&&(unite == 0))
                        strcat(lettre,"six cents ");
                    else
                        strcat(lettre,"six cent ");
                    break;
                case 7:
                    if((dizaine == 0)&&(unite == 0))
                        strcat(lettre,"sept cents ");
                    else
                        strcat(lettre,"sept cent ");
                    break;
                case 8:
                    if((dizaine == 0)&&(unite == 0))
                        strcat(lettre,"huit cents ");
                    else
                        strcat(lettre,"huit cent ");
                    break;
                case 9:
                    if((dizaine == 0)&&(unite == 0))
                        strcat(lettre,"neuf cents ");
                    else
                        strcat(lettre,"neuf cent ");
            }
            switch(dizaine)
            {
                case 0: /* C'est inutile */
                    break;
                case 1:
                    dix = TRUE;
                    break;
                case 2:
                    strcat(lettre,"vingt ");
                    break;
                case 3:
                    strcat(lettre,"trente ");
                    break;
                case 4:
                    strcat(lettre,"quarante ");
                    break;
                case 5:
                    strcat(lettre,"cinquante ");
                    break;
                case 6:
                    strcat(lettre,"soixante ");
                    break;
                case 7:
                    dix = TRUE;
                    strcat(lettre,"soixante ");
                    break;
                case 8:
                    strcat(lettre,"quatre-vingt ");
                    break;
                case 9:
                    dix = TRUE;
                    strcat(lettre,"quatre-vingt ");
            }
            switch(unite)
            {
                case 0:
                    if(dix == TRUE)
                        strcat(lettre,"dix ");
                        break;
                case 1:
                    if(dix == TRUE)
                        strcat(lettre,"onze ");
                    else
                        strcat(lettre,"un ");
                        break;
                case 2:
                    if(dix == TRUE)
                        strcat(lettre,"douze ");
                    else strcat(lettre,"deux ");
                    break;
                case 3:
                    if(dix == TRUE)
                        strcat(lettre,"treize ");
                    else
                        strcat(lettre,"trois ");
                    break;
                case 4:
                if(dix == TRUE)
                    strcat(lettre,"quatorze ");
                else
                    strcat(lettre,"quatre ");
                    break;
                case 5:
                    if(dix == TRUE)
                        strcat(lettre,"quinze ");
                    else
                        strcat(lettre,"cinq ");
                    break;
                case 6:
                    if(dix == TRUE)
                        strcat(lettre,"seize ");
                    else
                        strcat(lettre,"six ");
                    break;
                case 7:
                    if(dix)
                        strcat(lettre,"dix-sept ");
                    else
                        strcat(lettre,"sept ");
                    break;
                case 8:
                    if(dix == TRUE)
                        strcat(lettre,"dix-huit ");
                    else
                        strcat(lettre,"huit ");
                    break;
                case 9:
                    if(dix == TRUE)
                        strcat(lettre,"dix-neuf ");
                    else
                        strcat(lettre,"neuf ");
            }
            switch (i)
            {
                case 1000000000:
                    if(y>1)
                        strcat(lettre,"milliards ");
                    else
                        strcat(lettre,"milliard ");
                    break;
                case 1000000:
                    if(y>1)
                        strcat(lettre,"millions ");
                    else
                        strcat(lettre,"million ");
                    break;
                case 1000:
                    strcat(lettre,"mille ");
                    break; /* à ne pas oublier */
            }
        }
        reste -= y*i;
        dix = FALSE;
    }
    if(strlen(lettre)==0)
        strcpy(lettre,"zero");
}

30/12/2009, 10h51
waldomania

merci Driss tu es le Boss
j'ai compiler le travail et elle est vraiment fonctionnel dans Dev c++
le probleme est que j'ai esaayer ton code et ça pas marché dans Borland C++.
j'ai commencé à devenir fou car je dois simuler le programme dans le fac en utilisant Borland C et pas Devc++.
Avez une idée sur ça?
Merci et encore merci d'avance.
30/12/2009, 11h02
ok.Idriss

Citation:

Envoyé par waldomania

merci Driss tu es le Boss

Oh je ne crois pas :aie: (très très loin d'être le plus expert).

Citation:

Envoyé par waldomania

j'ai compiler le travail et elle est vraiment fonctionnel dans Dev c++
le probleme est que j'ai esaayer ton code et ça pas marché dans Borland C++.
j'ai commencé à devenir fou car je dois simuler le programme dans le fac en utilisant Borland C et pas Devc++.
Avez une idée sur ça?
Merci et encore merci d'avance.

Je n'ai jamais essayé Borland (étant payant ?) mais avec GCC ça marche (ça devrait marcher partout normalement). Sinon je te recommande plutôt Code::Blocks que Dev qui n'est plus très à jour (C::B est très proche et utilise aussi MinGW).

Pour Borland, le problème ne vient pas du code AMHA ...

Sinon, on ne "simule" pas ce programme, on l'exécute ...
30/12/2009, 11h51
diogene

Citation:

...le probleme est que j'ai esaayer ton code et ça pas marché dans Borland C++....

Soit précis, qu'est-ce qui ne marche pas avec Borland ? la compilation ou l'exécution ?
30/12/2009, 13h59
waldomania

la compilation est terminé avec succès mais y'a pas d'affichage dans l'exécution c'est à dire il affiche que de vide

Code:

printf("\nEn lettre ca fait %s: ", lettre);

y'a pas d'affichage ici.
merci d'avance.

borland C++ v3.1
30/12/2009, 14h12
ok.Idriss

As-tu un fichier.exe ? Tu l'exécute depuis l'IDE ou manuellement (en cliquant sur le .exe) ?
Un screen serait peut être utile.
30/12/2009, 14h45
waldomania

1 pièce(s) jointe(s)

voila un imprime ecran

1 - Essayes d'exécuter directement le fichier.exe
2 - Essayes ce code (c'est peut être le format %s qui passe pas) :

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
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
 
# define TRUE 1
# define FALSE 0
 
void clean_stdin (void) /* Procédure pour vider le buffer */
{
    int c = 0;
    do
    {
        c = getchar();
 
    } while (c != '\n' && c != EOF);
}
 
void ChiffreEnLettre(unsigned int, char*);
 
int main(void) /* Syntaxe correcte */
{
    unsigned x = 0;
    char choix = 'o', c[256];
    int i = 0;
    while((choix=='o')||(choix=='O'))
    {
        printf ("Introduire un chiffre entier : ");
        scanf ("%u", &x); /* bon format pour les unsigned */
        ChiffreEnLettre(x,c);
        printf ("\nEn lettre ca fait : ");
        while (c[i] != '\0')
        {
            printf ("%c", c[i]);
            i++;
        }
        printf ("\n\nEncore d'autre? (O/N): ");
        clean_stdin ();/* on vide le buffer */
        choix = getchar (); /* Il t'es possible d'utiliser getch () si tu le souhaites (avec conio.h toujours), je l'ai remplacé pour la portabilité */
        printf("\n===================================================\n");
    }
    return 0;
 }
 
/* Une bonne identation est correcte pour relire le code */
 void ChiffreEnLettre(unsigned int chiffre, char * lettre)
 {
    unsigned int centaine, dizaine, unite, reste, y;
    int dix = FALSE, i = 0;
    strcpy(lettre, "");
    reste = chiffre;
    for(i=1000000000; i>=1; i/=1000)
    {
        y = reste/i;
        if(y!=0)
        {
            centaine = y/100;
            dizaine = (y - centaine*100)/10;
            unite = y-(centaine*100)-(dizaine*10);
            switch(centaine)
            {
                case 0: /* Oo */
                    break;
                case 1:
                    strcat(lettre,"cent ");
                    break;
                case 2:
                    if((dizaine == 0)&&(unite == 0))
                        strcat(lettre,"deux cents ");
                    else
                        strcat(lettre,"deux cent ");
                    break;
                case 3:
                    if((dizaine == 0)&&(unite == 0))
                        strcat(lettre,"trois cents ");
                    else
                        strcat(lettre,"trois cent ");
                    break;
                case 4:
                    if((dizaine == 0)&&(unite == 0))
                        strcat(lettre,"quatre cents ");
                    else
                        strcat(lettre,"quatre cent ");
                    break;
                case 5:
                    if((dizaine == 0)&&(unite == 0))
                        strcat(lettre,"cinq cents ");
                    else
                        strcat(lettre,"cinq cent ");
                    break;
                case 6:
                    if((dizaine == 0)&&(unite == 0))
                        strcat(lettre,"six cents ");
                    else
                        strcat(lettre,"six cent ");
                    break;
                case 7:
                    if((dizaine == 0)&&(unite == 0))
                        strcat(lettre,"sept cents ");
                    else
                        strcat(lettre,"sept cent ");
                    break;
                case 8:
                    if((dizaine == 0)&&(unite == 0))
                        strcat(lettre,"huit cents ");
                    else
                        strcat(lettre,"huit cent ");
                    break;
                case 9:
                    if((dizaine == 0)&&(unite == 0))
                        strcat(lettre,"neuf cents ");
                    else
                        strcat(lettre,"neuf cent ");
            }
            switch(dizaine)
            {
                case 0: /* C'est inutile */
                    break;
                case 1:
                    dix = TRUE;
                    break;
                case 2:
                    strcat(lettre,"vingt ");
                    break;
                case 3:
                    strcat(lettre,"trente ");
                    break;
                case 4:
                    strcat(lettre,"quarante ");
                    break;
                case 5:
                    strcat(lettre,"cinquante ");
                    break;
                case 6:
                    strcat(lettre,"soixante ");
                    break;
                case 7:
                    dix = TRUE;
                    strcat(lettre,"soixante ");
                    break;
                case 8:
                    strcat(lettre,"quatre-vingt ");
                    break;
                case 9:
                    dix = TRUE;
                    strcat(lettre,"quatre-vingt ");
            }
            switch(unite)
            {
                case 0:
                    if(dix == TRUE)
                        strcat(lettre,"dix ");
                        break;
                case 1:
                    if(dix == TRUE)
                        strcat(lettre,"onze ");
                    else
                        strcat(lettre,"un ");
                        break;
                case 2:
                    if(dix == TRUE)
                        strcat(lettre,"douze ");
                    else strcat(lettre,"deux ");
                    break;
                case 3:
                    if(dix == TRUE)
                        strcat(lettre,"treize ");
                    else
                        strcat(lettre,"trois ");
                    break;
                case 4:
                if(dix == TRUE)
                    strcat(lettre,"quatorze ");
                else
                    strcat(lettre,"quatre ");
                    break;
                case 5:
                    if(dix == TRUE)
                        strcat(lettre,"quinze ");
                    else
                        strcat(lettre,"cinq ");
                    break;
                case 6:
                    if(dix == TRUE)
                        strcat(lettre,"seize ");
                    else
                        strcat(lettre,"six ");
                    break;
                case 7:
                    if(dix)
                        strcat(lettre,"dix-sept ");
                    else
                        strcat(lettre,"sept ");
                    break;
                case 8:
                    if(dix == TRUE)
                        strcat(lettre,"dix-huit ");
                    else
                        strcat(lettre,"huit ");
                    break;
                case 9:
                    if(dix == TRUE)
                        strcat(lettre,"dix-neuf ");
                    else
                        strcat(lettre,"neuf ");
            }
            switch (i)
            {
                case 1000000000:
                    if(y>1)
                        strcat(lettre,"milliards ");
                    else
                        strcat(lettre,"milliard ");
                    break;
                case 1000000:
                    if(y>1)
                        strcat(lettre,"millions ");
                    else
                        strcat(lettre,"million ");
                    break;
                case 1000:
                    strcat(lettre,"mille ");
                    break; /* à ne pas oublier */
            }
        }
        reste -= y*i;
        dix = FALSE;
    }
    if(strlen(lettre)==0)
        strcpy(lettre,"zero");
}

Et dit nous si ça marche.

31/12/2009, 08h46
waldomania

oui c bon ça marche apres reinstallation de borland.merci à tous
31/12/2009, 09h48
ok.Idriss

Salut.
Dans ce cas n'oublies pas de mettre en :resolu:.