je ne vois pas de point-virgule manquant

Version imprimable

Bonjour,

je ne vois pas où manque le point-virgule

quelqu'un peut m'aider?

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
#include <string>
#include <iostream>
#include "nombres.hpp"
 
nombre::nombre(bool signepositif,std::string valentiere,std::string valdecimale):positif(signepositif),entiere(valentiere),decimale(valdecimale) { }
 
nombre nombre::moitier(bool &impaire){
  std::string resultatentiere="";
  std::string copieentiere=entiere;//partie entiere
  char reste='0';
  char chiffrequotient;
  while(copieentiere!=""){
    switch(copieentiere[0]){
    case '0':case '1':
      chiffrequotient='0';
      break;
    case'2':case'3':
      chiffrequotient='1';
      break;
    case'4':case'5':
      chiffrequotient='2';
      break;
    case'6':case'7':
      chiffrequotient='3';
      break;
    case'8':case'9':
      chiffrequotient='4';
      break;
    }
    if(reste=='1')
      chiffrequotient+=(char)5;
    switch(copieentiere[0]){
    case'1':case'3':case'5':case'7':case'9':
      reste='1';
      break;
    default:
      reste='0';
    }
    resultatentiere+=chiffrequotient;
    copieentiere=copieentiere.substr(1);
  }
  std::string resultatdecimale="";
  if(!entier() || reste=='1'){
    std::string copiedecimale=decimale;//partie decimale
    while(copiedecimale!=""){
      switch(copiedecimale[0]){
      case '0':case '1':
	chiffrequotient='0';
	break;
      case'2':case'3':
	chiffrequotient='1';
	break;
      case'4':case'5':
	chiffrequotient='2';
	break;
      case'6':case'7':
	chiffrequotient='3';
	break;
      case'8':case'9':
	chiffrequotient='4';
	break;
      }
      if(reste=='1')
	chiffrequotient+=(char)5;//quotients égaux à 5,6,7,8,9
      switch(copiedecimale[0]){
      case'1':case'3':case'5':case'7':case'9':
	reste='1';
	break;
      default:
	reste='0';
      }
      resultatdecimale+=chiffrequotient;
      copiedecimale=copiedecimale.substr(1);
      if(copiedecimale==""&&reste=='1')
	copiedecimale="0";
    }
  }
  nombre resultat(positif,resultatentiere,resultatdecimale);
  resultat.normaliser();
  return resultat;
}
 
nombre nombre::doubler(){
  std::string nombre=entiere + decimale;
  std::string resultat="";
  char retenue=0;
  for(size_t i=nombre.size();i>0;i--){
    char onpause='\0';
    switch(nombre[i-1]){
    case '0':case '5':
      onpause='0';
      break;
    case '1':case'6':
      onpause='2';
      break;
    case '2':case '7':
      onpause='4';
      break;
    case '3':case'8':
      onpause='6';
      break;
    case '4':case'9':
      onpause='8';
    }
    onpause+=retenue;
    if(nombre[i-1]>='5')
      retenue=1;
    else
      retenue=0;
    resultat=onpause+resultat;
  }
  if(retenue==1)
    resultat="1"+resultat;
  int nbentiers=resultat.size()-decimale.size();
  nombre retour(positif,resultat.substr(0,nbentiers),resultat.substr(nbentiers));
  return retour;
}
 
bool nombre::entier(){
  bool estentier;
  if(decimale=="")
    estentier=true;
  else{
    estentier=true;
    for(size_t i=0;i<decimale.size();i++)
      if(decimale[i]!='0')
	estentier=false;
  }
  return estentier;
}
 
void nombre::ecrire(){
  if(positif)
    std::cout<<'+';
  else
    std::cout<<'-';
  std::cout<<entiere;
  if(!entier())
    std::cout<<','<<decimale;
}
 
void nombre::normaliser(){
  while(entiere.size()>1 && entiere[0]=='0')
    entiere=entiere.substr(1);
  while(decimale.back()=='0')
    decimale=decimale.substr(0,decimale.size()-1);
}

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
#ifndef NOMBRES_HPP
#define NOMBRES_HPP
 
#include <string>
 
class nombre{
private:
  bool positif;
  std::string entiere,decimale;
public:
  nombre(bool signepositif,std::string valentiere,std::string valdecimale);
  bool entier();
  bool nul;
  nombre moitier(bool &paire);
  nombre doubler();
  void ecrire();
  void normaliser();
};
#endif

Code:

1
2
3
4
5
6
7
8
9
g++ -c nombres.cpp
nombres.cpp: In member function ‘nombre nombre::doubler()’:
nombres.cpp:115:9: error: expected ‘;’ before ‘retour’
  115 |   nombre retour(positif,resultat.substr(0,nbentiers),resultat.substr(nbentiers));
      |         ^~~~~~~
      |         ;
nombres.cpp:116:10: error: ‘retour’ was not declared in this scope
  116 |   return retour;
      |          ^~~~~~

j'ai un peu modifié le comportement de cette classe et là, ça compile:

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
#ifndef NOMBRES_HPP
#define NOMBRES_HPP
 
#include <string>
 
class nombre{
private:
  bool positif;
  std::string entiere,decimale;
public:
  nombre(bool signepositif,std::string valentiere,std::string valdecimale);
  bool entier();
  bool nul;
  void moitier();
  void  doubler();
  void ecrire();
  void normaliser();
};
#endif

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
#include <string>
#include <iostream>
#include "nombres.hpp"
 
nombre::nombre(bool signepositif,std::string valentiere,std::string valdecimale):positif(signepositif),entiere(valentiere),decimale(valdecimale) { }
 
void nombre::moitier(){
  std::string resultatentiere="";
  std::string copieentiere=entiere;//partie entiere
  char reste='0';
  char chiffrequotient;
  while(copieentiere!=""){
    switch(copieentiere[0]){
    case '0':case '1':
      chiffrequotient='0';
      break;
    case'2':case'3':
      chiffrequotient='1';
      break;
    case'4':case'5':
      chiffrequotient='2';
      break;
    case'6':case'7':
      chiffrequotient='3';
      break;
    case'8':case'9':
      chiffrequotient='4';
      break;
    }
    if(reste=='1')
      chiffrequotient+=(char)5;
    switch(copieentiere[0]){
    case'1':case'3':case'5':case'7':case'9':
      reste='1';
      break;
    default:
      reste='0';
    }
    resultatentiere+=chiffrequotient;
    copieentiere=copieentiere.substr(1);
  }
  std::string resultatdecimale="";
  if(!entier() || reste=='1'){
    std::string copiedecimale=decimale;//partie decimale
    while(copiedecimale!=""){
      switch(copiedecimale[0]){
      case '0':case '1':
	chiffrequotient='0';
	break;
      case'2':case'3':
	chiffrequotient='1';
	break;
      case'4':case'5':
	chiffrequotient='2';
	break;
      case'6':case'7':
	chiffrequotient='3';
	break;
      case'8':case'9':
	chiffrequotient='4';
	break;
      }
      if(reste=='1')
	chiffrequotient+=(char)5;//quotients égaux à 5,6,7,8,9
      switch(copiedecimale[0]){
      case'1':case'3':case'5':case'7':case'9':
	reste='1';
	break;
      default:
	reste='0';
      }
      resultatdecimale+=chiffrequotient;
      copiedecimale=copiedecimale.substr(1);
      if(copiedecimale==""&&reste=='1')
	copiedecimale="0";
    }
  }
  nombre resultat(positif,resultatentiere,resultatdecimale);
  entiere=resultatentiere;
  decimale=resultatdecimale;
}
 
void nombre::doubler(){
  std::string nombre=entiere + decimale;
  std::string resultat="";
  char retenue=0;
  for(size_t i=nombre.size();i>0;i--){
    char onpause='\0';
    switch(nombre[i-1]){
    case '0':case '5':
      onpause='0';
      break;
    case '1':case'6':
      onpause='2';
      break;
    case '2':case '7':
      onpause='4';
      break;
    case '3':case'8':
      onpause='6';
      break;
    case '4':case'9':
      onpause='8';
    }
    onpause+=retenue;
    if(nombre[i-1]>='5')
      retenue=1;
    else
      retenue=0;
    resultat=onpause+resultat;
  }
  if(retenue==1)
    resultat="1"+resultat;
  int nbentiers=resultat.size()-decimale.size();
  entiere=resultat.substr(0,nbentiers);
  decimale=resultat.substr(nbentiers);
}
 
bool nombre::entier(){
  bool estentier;
  if(decimale=="")
    estentier=true;
  else{
    estentier=true;
    for(size_t i=0;i<decimale.size();i++)
      if(decimale[i]!='0')
	estentier=false;
  }
  return estentier;
}
 
void nombre::ecrire(){
  if(positif)
    std::cout<<'+';
  else
    std::cout<<'-';
  std::cout<<entiere;
  if(!entier())
    std::cout<<','<<decimale;
}
 
void nombre::normaliser(){
  while(entiere.size()>1 && entiere[0]=='0')
    entiere=entiere.substr(1);
  while(decimale.back()=='0')
    decimale=decimale.substr(0,decimale.size()-1);
}

11/11/2023, 00h59
emmesse

je crois que c'est à cause de ce genre de lignes:

Code:

std::string nombre=entiere + decimale;

Most vexing parse, lien wikipedia en angalis :mrgreen:

Je n'en suis pas sûr à 100%, mais cela ressemble à ce "bug", où le parser voit 1 déclaration de fonction à la place d'1 définition de variable.

Solutions possibles:
Code:

1 2 nombre retour = nombre(positif,resultat.substr(0, nbentiers), resultat.substr(nbentiers)); // C++98 et C++03 nombre retour{positif, resultat.substr(0,nbentiers), resultat.substr(nbentiers)}; // >= C++11, Uniform Initialization

11/11/2023, 10h23
CGi

Citation:

Envoyé par emmesse

je crois que c'est à cause de ce genre de lignes:

Code:

std::string nombre=entiere + decimale;

ta variable std::string nombre porte le même nom que ta classe, Quand tu créés un objet avec comme type une variable et bien le compilateur n'est pas content.

c'est bien ce que je pensais.
j'ai modifié ça:

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
std::string nombre::moitier_entier(std::string const &entierpourmult,bool &impaire){
  std::string resultat="";
  std::string traiter=entierpourmult;
  char reste='0';
  char chiffrequotient;
  while(traiter!=""){
    switch(traiter[0]){
    case '0':case '1':
      chiffrequotient='0';
      break;
    case'2':case'3':
      chiffrequotient='1';
      break;
    case'4':case'5':
      chiffrequotient='2';
      break;
    case'6':case'7':
      chiffrequotient='3';
      break;
    case'8':case'9':
      chiffrequotient='4';
      break;
    }
    if(reste=='1')
      chiffrequotient+=(char)5;
    switch(traiter[0]){
    case'1':case'3':case'5':case'7':case'9':
      reste='1';
      break;
    default:
      reste='0';
    }
    resultat+=chiffrequotient;
    traiter=traiter.substr(1);
  }
  if(reste=='1')
    impaire=true;
  else
    impaire=false;
  while(resultat.size()>1 && resultat[0]=='0')
    resultat=resultat.substr(1);
  return resultat;
}
 
std::string nombre::doubler_entier(std::string const &entierpourmult){
  std::string traiter=entierpourmult;
  std::string resultat="";
  char retenue=0;
  for(size_t i=traiter.size();i>0;i--){
    char onpause='\0';
    switch(traiter[i-1]){
    case '0':case '5':
      onpause='0';
      break;
    case '1':case'6':
      onpause='2';
      break;
    case '2':case '7':
      onpause='4';
      break;
    case '3':case'8':
      onpause='6';
      break;
    case '4':case'9':
      onpause='8';
    }
    onpause+=retenue;
    if(traiter[i-1]>='5')
      retenue=1;
    else
      retenue=0;
    resultat=onpause+resultat;
  }
  if(retenue==1)
    resultat="1"+resultat;
  while(resultat.size()>1 && resultat[0]=='0')
    resultat=resultat.substr(1);
  return resultat;
}

15/11/2023, 18h03
koala01
Salut,
Heu, tu n'as pas l'impression de te faire beaucoup de mal pour pas grand chose avec tout ce code :question:

Car les chaines de caractères, ce n'est vraiment pas le plus facile pour effectuer des calcul, même quand il s'agit de "simplement" diviser des chiffres par deux.

La "bonne" logique à mettre en place serait:
1. convertir ta chaine de caractères en valeur numérique avec la fonction std::stoi
2. (idéalement) t'assurer que toute la chaine de caractères a été convertie ("54321Hello" serait une erreur de ta part et devrait provoquer l'échec d'une assertion)
3. diviser la valeur numérique par deux, et récupérer aussi bien le résultat que le reste de cette division
4. convertir les résultat qui t'intéressent sous forme de chaine de caractères avec la fonction std::to_string
Tu pourrais alors t'en sortir avec un code "aussi simple" que ==>CECI<==
NOTA:
1- Le code qui t'intéresse réellement est celui de la fonction divise_par_deux, la fonction main n'étant là que pour te donner un exemple lors de l'exécution
2- Ne voulant pas créer une structure "nombre", j'ai profité de certaines possibilités apparues en C++17 pour récupérer les différentes valeurs sous différentes formes, ce qui explique la syntaxe peut-être bizare dans la fonction main ;)
3- la fonction std::stoi lance une exception s'il n'y a pas moyen de convertir la chaine de caractères transmise (si tu transmet la chaine de caractères "hello", par exemple).
Il ** pourrait être pas mal ** de récupérer cette exception potentielle dans un bloc try... catch au niveau de la fonction main
4- Par contre, s'il y a moyen de convertir ne serait-ce que le premier caractère de la chaine de caractères, la fonction std::stoi fonctionnera correctement.
Il faudrait donc ** idéalement ** mettre en place une logique qui vérifie que toute la chaine de caractères a bel et bien été convertie, histoire de pouvoir gérer le cas d'une chaine comme "1234hello", par exemple
5- au cas où tu te demanderait ce que c'est, un ==>std::tuple<== est l'agrégat générique par excellence fournit par la bibliothèque standard qui te permet de regrouper n'importe quel nombre de données de n'importe quel type sans avoir besoin ni de donner un nom pour le type de la structure, ni de donner un nom aux données qui la compose.
On peut -- si on récupère le tuple de manière plus classique -- accéder à chacune des donnée qui la composent sur base de sa position dans la structure au moyen de la fonction std::get<position_recherchée>(la_tuple).
Le tout étant évalué à la compilation.
La fonction std::make_tuple permet de générer un std::tuple sans trop se poser de question ;)
6- Désolé, tous les liens pointent sur des ressources en anglais, par habittude... Mais il s'agit généralement d'un anglais technique, assez simple. Et dis toi, si tu ne connais pas l'anglais, qu'il sera de toutes façons particulièrement intéressant pour toi de t'y mettre, car la très grosse majorité des ressources auxquelles tu sera confronté en programmation seront écrite dans la langue de Shakespeare ;)

ben, je fais ça pour le fun pour voir ce que ça donne, si j'ai envie de faire plus compliqué pour le fun, pourquoi pas?
en fait j'utilise les caractère numériques pour calculer avec des nombres très grands et avec des petits nombres (par exemple cent chiffres et trois chiffres).
la lecture des nombres se fera par un analyseur lexical. ce seront bien que des chiffres.
Pour l'instant ce sont les opérations basiques, multiplications à la russe.https://fr.wikipedia.org/wiki/Techni...ion_dite_russe
Ensuite, avec les quatre opérations je calculerais avec des parties entières et décimales et surcharge d'opérateurs.

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
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
std::string moitierstr(std::string const &entierpourmult,bool &impaire){
  std::string resultat="";
  std::string traiter=entierpourmult;
  char reste='0';
  char chiffrequotient;
  while(traiter!=""){
    switch(traiter[0]){
    case '0':case '1':
      chiffrequotient='0';
      break;
    case'2':case'3':
      chiffrequotient='1';
      break;
    case'4':case'5':
      chiffrequotient='2';
      break;
    case'6':case'7':
      chiffrequotient='3';
      break;
    case'8':case'9':
      chiffrequotient='4';
      break;
    }
    if(reste=='1')
      chiffrequotient+=(char)5;
    switch(traiter[0]){
    case'1':case'3':case'5':case'7':case'9':
      reste='1';
      break;
    default:
      reste='0';
    }
    resultat+=chiffrequotient;
    traiter=traiter.substr(1);
  }
  if(reste=='1')
    impaire=true;
  else
    impaire=false;
  while(resultat.size()>1 && resultat[0]=='0')
    resultat=resultat.substr(1);
  return resultat;
}
 
std::string doublerstr(std::string const &entierpourmult){
  std::string traiter=entierpourmult;
  std::string resultat="";
  char retenue=0;
  for(size_t i=traiter.size();i>0;i--){
    char onpause='\0';
    switch(traiter[i-1]){
    case '0':case '5':
      onpause='0';
      break;
    case '1':case'6':
      onpause='2';
      break;
    case '2':case '7':
      onpause='4';
      break;
    case '3':case'8':
      onpause='6';
      break;
    case '4':case'9':
      onpause='8';
    }
    onpause+=retenue;
    if(traiter[i-1]>='5')
      retenue=1;
    else
      retenue=0;
    resultat=onpause+resultat;
  }
  if(retenue==1)
    resultat="1"+resultat;
  while(resultat.size()>1 && resultat[0]=='0')
    resultat=resultat.substr(1);
  return resultat;
}
 
std::string multiplierentier(std::string const &multiplicande,std::string const &multiplicateur){
  std::string op1=multiplicande;
  std::string op2=multiplicateur;
  bool impaire;
  std::string resultat="";
  while(op2!="0"){
    op2=moitierstr(op2,impaire);
    if(impaire)
      resultat=additionentier(resultat,op1);
    op1=doublerstr(op1);
  }
  return resultat;
}
 
char additionchiffrestr(char operande1,char operande2,bool &retenue){
  std::string tableaddition[10][10]={
    {"0","1","2","3","4","5","6","7","8","9"},
    {"1","2","3","4","5","6","7","8","9","10"},
    {"2","3","4","5","6","7","8","9","10","11"},
    {"3","4","5","6","7","8","9","10","11","12"},
    {"4","5","6","7","8","9","10","11","12","13"},
    {"5","6","7","8","9","10","11","12","13","14"},
    {"6","7","8","9","10","11","12","13","14","15"},
    {"7","8","9","10","11","12","13","14","15","16"},
    {"8","9","10","11","12","13","14","15","16","17"},
    {"9","10","11","12","13","14","15","16","17","18"}
  };
  std::string tableadditionretenue[10][10]={
    {"1","2","3","4","5","6","7","8","9","10"},
    {"2","3","4","5","6","7","8","9","10","11"},
    {"3","4","5","6","7","8","9","10","11","12"},
    {"4","5","6","7","8","9","10","11","12","13"},
    {"5","6","7","8","9","10","11","12","13","14"},
    {"6","7","8","9","10","11","12","13","14","15"},
    {"7","8","9","10","11","12","13","14","15","16"},
    {"8","9","10","11","12","13","14","15","16","17"},
    {"9","10","11","12","13","14","15","16","17","18"},
    {"10","11","12","13","14","15","16","17","18","19"}
  };
  std::string calcul;
  if(retenue)
    calcul=tableadditionretenue[operande1-'0'][operande2-'0'];
  else
    calcul=tableaddition[operande1-'0'][operande2-'0'];
  char resultat;
  bool deuxchiffres;
  if(calcul.size()==2){
    deuxchiffres=true;
    resultat=calcul[1];
  }
  else{
    deuxchiffres=false;
    resultat=calcul[0];
  }
  retenue=deuxchiffres;
  return resultat;
}
 
std::string additionentier(std::string const &operande1,std::string const &operande2){
  std::string op1=operande1;
  std::string op2=operande2;
  while(op1.size()<op2.size())
    op1="0"+op1;
  while(op1.size()>op2.size())
    op2="0"+op2;
  bool retenue=false;
  std::string resultat;
  for(size_t i=op1.size();i>0;i--){
    char calcul=additionchiffrestr(op1[i-1],op2[i-1],retenue);
    resultat=calcul+resultat;
  }
  if(retenue)
    resultat='1'+resultat;
  return resultat;
}
 
std::string soustractionentier(std::string const &operande1,std::string const &operande2){
  std::string op1=operande1;
  std::string op2=operande2;
  if(plusgrandqueentier(op2,op1)){
    std::string temp=op1;
    op1=op2;
    op2=temp;
  }
  std::string resultat="";
  if(egalentier(op1,op2))
    resultat="0";
  else{
    while(op2.size()<op1.size())
      op2='0'+op2;
    char retenue=0;
    for(size_t i=op1.size();i>0;i--){
      char chiffre1=op1[i-1];
      char chiffre2=op2[i-1]+retenue;
      char chiffre;
      if(chiffre1>=chiffre2){
	chiffre=chiffre1-chiffre2+'0';
	retenue=0;
      }
      else{
	chiffre=chiffre1+10-chiffre2+'0';
	retenue=1;
      }
      resultat=chiffre+resultat;
    }
  }
  while(resultat[0]=='0')
    resultat=resultat.substr(1);
  return resultat;
}
 
bool plusgrandqueentier(std::string const &operande1,std::string const &operande2){
  std::string op1=operande1;
  std::string op2=operande2;
  while(op1.size()>1 && op1[0]=='0')
    op1=op1.substr(1);
  while(op2.size()>1 && op2[0]=='0')
    op2=op2.substr(1);
  bool resultat;
  if(op1.size()>op2.size())
    resultat=true;
  else if(op1.size()<op2.size())
    resultat=false;
  else{
    size_t i;
    for(i=0;i<op1.size() && op1[i]==op2[i];i++)
      ;
    if(i==op1.size())
      resultat=false; //opérandes égaux
    else if(op1[i]>op2[i])
      resultat=true;
    else
      resultat=false;
  }
  return resultat;
}
 
bool egalentier(std::string const &operande1,std::string const &operande2){
  std::string op1=operande1;
  std::string op2=operande2;
  while(op1.size()>1 && op1[0]=='0')
    op1=op1.substr(1);
  while(op2.size()>1 && op2[0]=='0')
    op2=op2.substr(1);
  bool resultat;
  if(op1.size()==op2.size()){
    size_t i;
    for(i=0;i<op1.size() && op1[i]==op2[i];i++)
      ;
    if(i==op1.size())
      resultat=true;
    else
      resultat=false;
  }
  else
    resultat=false;
  return resultat;
}
 
bool pluspetitqueentier(std::string const &operande1,std::string const &operande2){
  std::string op1=operande1;
  std::string op2=operande2;
  return !plusgrandqueentier(op1,op2) && !egalentier(op1,op2);
}
 
bool plusgrandouegalentier(std::string const &operande1,std::string const &operande2){
  std::string op1=operande1;
  std::string op2=operande2;
  return plusgrandqueentier(op1,op2) || egalentier(op1,op2);
}
 
bool pluspetitouegalentier(std::string const &operande1,std::string const &operande2){
  std::string op1=operande1;
  std::string op2=operande2;
  return !plusgrandqueentier(op1,op2);
}
 
bool differentsentier(std::string const &operande1,std::string const &operande2){
  std::string op1=operande1;
  std::string op2=operande2;
  return !egalentier(op1,op2);
}