convertir un chiffre en lettre

**faniette** · 03/11/2017, 23h48

pour convertir un chiffre en lettre j'ai utilisée ce code

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
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
float Entier;
Entier = StrToFloat(Label2->Caption);
char lettre[256]="";
unsigned int centaine, dizaine, unite, reste, y;
bool dix = false;
reste = Entier;
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 ");
            }
            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 ");
            } 
            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");
 
Label1->Caption=lettre;

ce code fonctionne tres bien sauf dans le cas par ex 1945 résultat donne

Code :

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

Un mille neuf cent quarante cinq

je veut

Code :

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

mille neuf.........

sans Un
merci d'avance pour votre aide

**dalfab** · 04/11/2017, 12h09

Bonjour,

Si on est dans les "mille", on ne doit pas écrire le "un" s'il est seul. Ça devient ligne 105

Code :

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

if ( i!=1000 || centaine || dizaine ) StrCat(lettre,"Un ");

Et on ne dit pas "Vingt Un" mais "Vingt-et-un", il manque donc aussi autre chose.

**faniette** · 04/11/2017, 15h52

Merciiiiiiiiiiiiii beaucoup dalfab.

vous avez raison concernant cette remarque

Code :

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

Et on ne dit pas "Vingt Un" mais "Vingt-et-un"

vous pouvez me dirigé pour résoudre ce probleme.
merci encore une autre fois.

**dalfab** · 04/11/2017, 17h39

Si on oublie les tirets de la nouvelle orthographe (qui sont manquant partout) et qui amènerait une grosse modification sur la gestion des espaces. Ce que l'on veut c'est écrire "et un" au lieu de "un" quand la dizaine est comprise entre 2 et 6, ça n'est pas si difficile.

**Pyramidev** · 04/11/2017, 19h29

Bonjour,

Il faudrait transformer le pâté de code en programme structuré.

Dans ton code, tu récupères une chaîne dans un composant graphique Label2, puis tu la convertie en entier, puis tu as un gros code qui convertit cet entier en une chaîne que tu mets dans un autre composant graphique Label1. Le gros bout de code en question devrait être isolé dans une fonction.

Exemple : fichier "FrenchUtility.h" :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
#ifndef INCLUDE__MY_PROJECT__FRENCH_UTILITY__H
#define INCLUDE__MY_PROJECT__FRENCH_UTILITY__H
 
#include <string>
 
namespace MyProject::FrenchUtility {
 
	std::string convertToFrenchUtf8String(int number);
 
} // namespace MyProject::FrenchUtility
 
#endif

Cette fonction peut elle-même être décomposée en sous-fonctions.

Exemple : fichier "FrenchUtility.cpp" :

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
#include "FrenchUtility.h"
 
#include <cstdint>
#include <limits>
#include <string>
 
namespace MyProject {
 
namespace {
	constexpr std::intmax_t cMAX_INTEGER_FOR_FRENCH_STRING = INTMAX_C(999'999'999'999);
	constexpr std::intmax_t cMIN_INTEGER_FOR_FRENCH_STRING = -cMAX_INTEGER_FOR_FRENCH_STRING;
 
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wtype-limits"
	static_assert(std::numeric_limits<int>::max() <= cMAX_INTEGER_FOR_FRENCH_STRING);
	static_assert(std::numeric_limits<int>::min() >= cMIN_INTEGER_FOR_FRENCH_STRING);
#pragma GCC diagnostic pop
 
	std::string convertToFrench(unsigned number);
	// D'autres fonctions déclarées en avance...
}
 
std::string FrenchUtility::convertToFrenchUtf8String(int number)
{
	const std::string prefix = (number < 0) ? u8"moins " : u8"";
	const auto positiveNumber = static_cast<unsigned>((number < 0) ? -number : number);
	return prefix + convertToFrench(positiveNumber);
}
 
namespace
{
	std::string convertToFrench(unsigned number)
	{
		// Du code...
	}
 
	// Les définitions des autres fonctions...
}
 
} // namespace MyProject

Ensuite, pour tester ce genre de fonction, le mieux, c'est de faire des tests unitaires.

Exemple avec Boost.Test sur GCC :

main.cpp :

Code :

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

1
2
3
4
5
6
7
8
9
10
#define BOOST_TEST_MODULE Unit tests of MyProject
 
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Weffc++"
#pragma GCC diagnostic ignored "-Wmissing-declarations"
#pragma GCC diagnostic ignored "-Wold-style-cast"
#pragma GCC diagnostic ignored "-Woverloaded-virtual"
#pragma GCC diagnostic ignored "-Wzero-as-null-pointer-constant"
# include <boost/test/unit_test.hpp>
#pragma GCC diagnostic pop

FrenchUtilityTest.cpp :

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
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Weffc++"
#pragma GCC diagnostic ignored "-Wold-style-cast"
#pragma GCC diagnostic ignored "-Woverloaded-virtual"
#pragma GCC diagnostic ignored "-Wzero-as-null-pointer-constant"
# include <boost/test/unit_test.hpp>
#pragma GCC diagnostic pop
 
#include "MyProject/FrenchUtility.h"
 
namespace MPFU = MyProject::FrenchUtility;
 
BOOST_AUTO_TEST_SUITE(FrenchUtilityTest_TheTestSuite)
 
BOOST_AUTO_TEST_CASE(SomeTest)
{
	BOOST_TEST(MPFU::convertToFrenchUtf8String(0)   == u8"zéro");
	BOOST_TEST(MPFU::convertToFrenchUtf8String(1)   == u8"un");
	BOOST_TEST(MPFU::convertToFrenchUtf8String(-1)  == u8"moins un");
	BOOST_TEST(MPFU::convertToFrenchUtf8String(11)  == u8"onze");
	BOOST_TEST(MPFU::convertToFrenchUtf8String(-11) == u8"moins onze");
}
 
BOOST_AUTO_TEST_SUITE_END()

Remarques spécifiques à C++ Builder :

Il faudra enlever mes #pragma GCC, car C++ Builder n'en tiendra pas compte.
Comme Embarcadero est en retard sur le C++, il y aura probablement quelques adaptations à faire dans le code pour que ça compile.
A la place de Boost.Test, tu peux utiliser le framework de tests unitaires de Embarcadero.

**faniette** · 04/11/2017, 22h41

Salut
voici le code que j'ai utilisée

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
case 1:
                    if(dix)
                    {
                    StrCat(lettre,"Onze ");
                    }
                    else
                    {
                  if ( i!=1000 || centaine || dizaine  )
                     {
                       if(dizaine ==0 )
                          {
                               StrCat(lettre,"Un ");
                           }
                             else
                             {  if ( ((dizaine >=2) && (dizaine <=6)||(dizaine ==8)) )
                                 {
                                  StrCat(lettre,"-et-Un ");
                                  }
                             }
 
                      }
                     }
                    break;

convertir un chiffre en lettre

C++Builder

Vue hybride

Discussions similaires

Partager

Partager