opération mathématique à partir d'une variable de type string

Version imprimable

13/06/2022, 21h44
binco

opération mathématique à partir d'une variable de type string

Bonjour

J'ai une variable de type "string" composée de chiffres et d'opérateurs

Code:

std::string cadre_input_calcul = "1+2-3/4*5";

Comment faire pour calculer l'opération?

Code:

float operation= ??cadre_input_calcul??

Cordialement
13/06/2022, 22h24
dalfab

Bonjour,

Il n'existe aucune fonction qui évaluerait le texte dans une chaine de caractère. Il te faut un code qui "lise" la chaine, y détecte les nombres et symboles, et effectue alors les actions nécessaires.

merci

pour détecter les nombres

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
 
#include <stdio.h>
#include <string>
#include <sstream>
#include <typeinfo>		// pour typeid
#include <ctype.h>      // pour isdigit()
#include <iostream>		// pour cout
#include <regex>
 
 
int main( int argc, char* args[] )
{
    const std::string string3 = "9,42+308,7-41+36*234,56/546+7.56*769,3";
    std::regex  regex3("([0-9]+[.|,]{0,1}[0-9]*)");  
    std::smatch match3;
    if (regex_search(string3, match3, regex3))
    {
        for (int i=1; i<match3.size(); i++) 
        {
            std::cout << match3[i] << std::endl;
        }
    }
return 0;
}

problème: il ne fait apparaitre que le premier nombre: 9,42

Sur la documentation cplusplus.com std::regex_search, il faut relancer la recherche.
Et toutes les entêtes C comme stdio.h ont 1 version C++ cstdio (on retire l'extension .h et on préfixe 1 c)

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
#include <iostream>
#include <regex>
 
#include <cstdlib>
 
 
int main(int argc, char* args[])
{
    std::string string3 = "9,42+308,7-41+36*234,56/546+7.56*769,3";
    std::regex  regex3("([0-9]+[.|,]{0,1}[0-9]*)");  
    std::smatch match3;
 
    while( regex_search(string3, match3, regex3) ) {
        for (auto x:match3) { std::cout << x << " "; }
        std::cout << std::endl;
 
        string3 = match3.suffix().str();
    }
 
 
    return EXIT_SUCCESS;
}

16/06/2022, 13h53
binco

merci

je ne vois pas comment récupérer les valeurs sous forme terme_facteur[i]=x[i]

Salut,

A vrai dire, les expressions régulières ne te seront pas d'un très grand secours pour résoudre ton problème. Je m'explique:

Une expression régulière va parcourir une "chaine de caractères d'origine" à la recherche d'un patron, représenté sous la forme d'une chaine de caractères, qui permettra à l'expression régulière d'extraire une "sous chaine de caractères" de la "chaine d'origne" si le patron recherché est trouvé.

C'est certes très pratique, mais... cela ne remplit certainement pas l'ensemble de nos besoins, car ceux-ci vont "un cran plus loin" en nécessitant de convertir les chaines de caractères qui représentent des nombres en valeurs numériques.

Attention, je ne dis absolument pas que l'on ne peut en aucun cas avoir recours aux expressions régulières. Je dis juste que c'est peut être se faire "beaucoup de mal pour rien", car les moyens dont on dispose pour convertir une chaine de caractères en valeur numérique ne nécessitent absolument pas que la chaine convertie ne soit composée que du nombre à convertir.

De manière générale, pour extraire les valeurs numériques d'une chaine de caractères en C++, tu dois utiliser les fonctions std::sto* (std::stoi et autres pour les entiers, std::stof, std::stod, et std::stold pour les réels).

Le deuxième paramètre (le premier qui soit optionnel) nous permet de fournir un pointeur sur un entier qui correspondra à la position du premier caractère de la chaine de caractères qui "ne fait clairement pas partie du nombre".

Par contre, il faudra jouer avec les "sous-chaines de caractères" afin de pouvoir récupérer les différents opérateurs et, au delà, l'expression complète que l'on souhaite évaluer.

Par contre, il va aussi falloir prendre en compte le fait que la partie décimale d'un nombre en informatique est représentée par le point "." et non par la virgule ","

Ainsi, si on veut traiter une chaine de caractères (que je vais utiliser tout au long de cette explication) qui prend la forme de " std::string str = "9,42+308,7-41+36*234,56/546+7.56*769,3";, les deux premières choses que nous voudrons faire sont:

effectuer une "copie de travail" de la chaine, afin de ne pas aller modifier la chaine "d'origine"
remplacer toutes les virgules qui apparaissent par des points, histoire que nos fonctions de conversion y "retrouvent leur jeunes".

La première étape est toute simple, car il nous suffira d'une ligne proche de

Code:

std::string copy{str};

pour avoir une variable nommée copy qui est la copie conforme de la chaine de caractères str.

La deuxième étape n'est a priori pas beaucoup plus compliquée, car nous disposons d'une fonction d'algorithme nommé std::replace_if capable de le faire pour nous (il faut juste penser à inclure le fichier d'en-tête <algorithm>). Une ligne proche de

Code:

std::replace_if(copy.begin(), copy.end(), [](char c){return c==',';},'.');

devrait faire l'affaire
Je sais, elle a l'air compliquée comme cela, mais elle en fait, elle est toute simple et parfaitement logique... si tu ne la comprends pas, n'hésite pas à me le dire, je t'expliquerai le tout au besoin ;)

Bien, maintenant que nous avons la certitude que la chaine de caractères (copy) pourra être traitée correctement avec la fonction std::stof, il est peut être utile de prendre trente secondes pour réfléchir à notre situation actuelle et au résultat que l'on souhaite obtenir...

Notre situation actuelle est que nous sommes désormais face à une chaine de caractères dont on peut clairement dire qu'il s'agit "d'une expression mathématique" (complexe).

Notre objectif de départ étant de récupérer les différentes valeurs numériques que cette expression contient, ainsi que ... les opérateurs mathématiques qui séparent ces différentes valeurs (ce sera plus facile, semblet-t-il, pour atteindre l'objectif final :D).

L'objectif final étant de pouvoir évaluer le résultat de cette expression une fois que toutes les opérations auront été effectuées. Accessoirement, s'il y avait moyen de respecter les règles de priorités pour les différents opérateurs, ce serait franchement pas mal ;)

Tiens, au fait... Je viens d'introduire quelques notions sympa ici, dont la notion d'"opérateurs mathématiques". Comme ces opérateurs seront essentiels au calcul du résultat final, nous serions peut être bien inspirés d'introduire cette notion dans notre "DSL" (acronyme de Domain Specific Language ou, si tu préfères, notre langage spécifique au domaine de notre projet).
Le plus simple serait sans doute de créer une énumération reprenant les quatre opérations de base et qui serait proche
Code:

1 2 3 4 5 6 7 8 enum MathOperator{ plus, minus, multiply, divide, max };
La valeur "max" n'est présente ici que pour une question de facilité, car elle nous permettra par la suite des choses sympa ... ou non ;)

Et, bien sur, on pourrait fournir une fonction qui fournisse la valeur énumérée correspondant au symbole représenté par le caractère en question:
Code:

1 2 3 4 5 6 7 8 9 10 constexpr MathOperator mathFromChar(char c){ switch c{ case '+' : return plus; case '-' : return minus; case '*' : return multiply; case '/' : return divide; default : assert(false && You should never come here"); } return max; }
Cette fonction est déclarée comme étant constexpr uniquement parce que cela permettra au compilateur de faire quelques optimisations supplémentaires ;)

Maintenant que nous avons une fonction pour extraire un float (je parle bien sur de std::stof) et une autre fonction pour récupérer le type d'opérateur mathématique utilisé dans le cadre de "l'expression mathématique dont on veut calculer le résultat, ben ... YAPUKA ... mettre tout cela en musique ;)

Pour se faire, nous aurons encore besoin de deux variables particulières:
un float, d'abord, pour pouvoir extraire les réels représentés par la chaine de caractères et
un size_t ensuite, pour savoir la position du "premier caractère n'ayant pas été utilsé par la fonction.

le float peut être déclaré au moment où l'on récupère le résultat de std::stof, par contre le size_t devra être déclaré avant (car on doit en prendre l'adresse pour la transmettre à stof...).

Cela pourrait prendre une forme proche de
Code:

1 2 3 size_t position{0}; float extracted = std::stof(copy, &position);
Nous pouvons "assez facilement" utiliser la nouvelle valeur de position pour récupérer l'opérateur mathémathique sous une forme proche de

Code:

MathOperator oper = mathFromChar(copy[position]);

Bien sur, nous ne devons donc pas oublier que le premier caractère qui nous intéresse se trouve désormais à position +1, mais il est désormais temps de supprimer "tout ce qui a déjà été traité" de la chaine:

Code:

copy = copy.substr(position + 1);

Nous sommes désormais rendus au point où
nous avons extrait la première valeur numérique de la chaine de caractères
nous avons extrait le premier opérateur mathématique de la chaine de caractères
nous avons supprimé de la chaine de caractères tous les caractères qui ont déjà été utilisés lors des deux extractions sus-citées.

Ce qu'il faut désormais, c'est "continuer sur cette lancée" afin de parcourir toute la chaine de caractères... Et ca, je vais te laisser faire, autrement, cela n'aurait absolument aucun intérêt :D

Dans l'idéal, il faudrait trouver le moyen de stocker toutes les informations obtenues, histoire que l'on puisse les manipuler "à notre aise" ... après avoir parcouru toute la chaine de caractères ;)

Fais attention au fait qu'il y a peut être une petite astuce à la fin de la chaine de caractères, étant donné qu'elle est censée se cloturer par ... une valeur numérique;)

Une fois que nous aurons parcouru l'ensemble de la chaine de caractères, il faudra trouver le moyen de "recréer" l'expression mathématique qu'elle représentait de manière à pouvoir en calculer le résultat final.

Soit toujours bien attentif au fait que la multiplication et la division ont priorité sur l'addition lorsque tu évalue le résultat final.

Une fois que tu en sera rendu là, nous pourrons éventuellement améliorer le tout en ajoutant le support d'espaces "surnuméraires" (par exemple avant et après un opérateur mathématique), mais ... à chaque jour suffit sa peine, n'est ce pas?

17/06/2022, 16h33
Bousk

Ça ressemble furieusement à un exercice qu'on faisait déjà il y a 20 ans en école.
Il n'y a bien sûr pas de solution miracle parce que le but est justement de programmer une solution.
L'objectif est de parcourir la chaîne de caractère et extraire les informations pour recréer les nombres et opérations.
Je me souviens avoir fait ça avec des opérations en notation polonaise inversée.:aie:
24/06/2022, 13h58
Médinoc

La partie problématique, c'est généralement la prise en compte des priorités opératoires. Sans ça, c'est presque trivial.

Citation:

Envoyé par Bousk

Je me souviens avoir fait ça avec des opérations en notation polonaise inversée.:aie:

Une opération saisie en NPI facilite grandement les choses, vu que le programme n'a plus à se préoccuper des priorités vu que l'utilisateur l'a fait pour lui: Il itère son algorithme contre sa pile et c'est tout. Par contre, si on demandait de convertir une opération depuis "9,42+308,7-41+36*234,56/546+7.56*769,3" vers de la NPI...:aie::aie:

PS: la même opération en NPI devrait être:

9,42 308,7 + 41 - 36 234.45 * 546 / + 7,56 769,3 * +
24/06/2022, 15h40
foetus
C'est 1 exercice classique parce qu'il faut programmer 1 machine à états/ automate.
En plus le résultat intermédiaire est 1 arbre [peut-être binaire] les nœuds sont les opérateurs, les feuilles sont les valeurs, et 1 parcours postfixe pour lire le résultat

Avec par exemple [en gros mais sûrement faux]
pour les mots :
- mul_div = * ou /
- add_sub = + ou -
- valeur = [0..9]+[.[0..9]*]*
pour la grammaire :
- expression = term ou term add_sub expression
- term = valeur ou valeur mul_div term
Et ensuite, il y a de grandes chances qu'on va te demander de gérer certains "nombres magiques" (comme pi), les signes, les parenthèses, les puissances, les fonctions, ...

J'ai essayé avec vector<int>. Mon code fonctionne avec le std::string str = "9,42+308,7-41+36*234,56/546+7.56*769,3+3" de l'exemple mais n'est pas générique. Pouvez vous m'aidez?

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
 
#include <string>
#include <iostream>
#include <regex>
#include <typeinfo>
#include <cassert>
#include <list>
#include <numeric>  // accumulate
 
using namespace std;
 
// énumération reprenant les quatre opérations de base
enum MathOperator{
    addition,
    soustraction,
    multication,
    division,
    vide
};
 
constexpr MathOperator mathFromChar(char c){
    switch (c)
    {
        case '+' : return addition;
        case '-' : return soustraction;
        case '*' : return multication;
        case '/' : return division;
    }
    return vide;
}
 
int main()
{
    std::string str = "9,42+308,7-41+36*234,56/546+7.56*769,3+3";
    // copie du string
    std::string copie_de_str {str};  // <=> std::string copie_de_str = str;
    // remplacer les , par des .
    std::replace_if(copie_de_str.begin(), copie_de_str.end(), [](char c){return c==',';},'.');
    cout << "std::replace_if: " << copie_de_str << endl;
    int longueur_initiale = copie_de_str.length();
    cout << "longueur_initiale: " << longueur_initiale << endl;
    // savoir la position du "premier caractère n'ayant pas été utilsé par la fonction
    size_t position{0};
    cout << "size_t position{0}: " << position << endl;    
 
    // longueur de la chaine restante
    int difference = longueur_initiale-position;
    int difference_bis = 0;    
 
    // tableau de termes ou facteurs
    float * tableau_terme_facteur = new float;    // allouer de la mémoire
    int i = 0;
 
    // tableau d operateurs
    int * tableau_operateur_calcul = new int;
    int j = 0;
 
    cout << endl;
 
    // calcul de l operation
    float resultat_final = 0;
 
    // conteneur des termes ou facteurs
    vector<float> vector_terme_facteur;
    // conteneurs des operateurs
    vector<int> vector_operateur;
 
    while (difference)
    {
        // affichage index
        cout << "i: " << i << endl;
 
        //  extraire les réels représentés par la chaine de caractères
        float extracted_terme_facteur = std::stof(copie_de_str, &position);
        cout << "extracted_terme_facteur: " << extracted_terme_facteur << endl;
        cout << "size_t position: " << position << endl; 
        // tableau des termes ou facteurs
        tableau_terme_facteur[i] = extracted_terme_facteur;
 
        int difference_bis = longueur_initiale - (position+1);
        cout << "difference_bis: " << difference_bis << endl;  
 
        // utiliser la nouvelle valeur de position pour récupérer l'opérateur mathémathique
        cout << "copie_de_str[position]: " << copie_de_str[position] << endl;
        MathOperator extracted_operateur_calcul = mathFromChar(copie_de_str[position]);
        // tableau des operateurs
        tableau_operateur_calcul[j] = extracted_operateur_calcul;
 
        cout << "MathOperator oper: " << extracted_operateur_calcul << endl;
        cout << "position+1: " << position + 1 << endl;
 
        // caracteres restants apres extraction termes/facteurs et opérateur
        if(difference_bis>=0)
        {
            copie_de_str = copie_de_str.substr(position + 1); // +1 <=> 1 caractere pour l operateur
            // substr(): Copie une sous-chaîne d'un certain nombre de caractères dans une chaîne qui commence à la position spécifiée
            cout << "copie_de_str: " << copie_de_str << endl;
        }
        // nombre total de caracteres restants dans la chaine
        int longueur_bis = copie_de_str.length();
        cout << "longueur_bis: " << longueur_bis << endl;
        difference = longueur_bis-position;
        cout << "difference: " << difference << endl << endl;
 
        longueur_initiale = difference_bis;
 
        // incrementation index
        i++;
        j++;  
    }
 
    // affichage tableau_terme_facteur
    for(int j=0; j<sizeof(tableau_terme_facteur)+1; j++)
    {
        cout << "tableau_terme_facteur["<<j<<"]: " << tableau_terme_facteur[j] << endl;
    }
    cout << endl;
    cout << "sizeof(tableau_terme_facteur): " << sizeof(tableau_terme_facteur) << endl;
 
    // affichage tableau_operateur_calcul
    for(int j=0; j<sizeof(tableau_operateur_calcul)+1; j++)
    {
        cout << "tableau_operateur_calcul["<<j<<"]: " << tableau_operateur_calcul[j] << endl;
    }
    cout << endl;
    cout << "sizeof(tableau_operateur_calcul): " << sizeof(tableau_operateur_calcul) << endl;
 
    // vector_terme_facteur 
    for(i=0; i < sizeof(tableau_terme_facteur)+1; i++)
    {
        vector_terme_facteur.push_back(tableau_terme_facteur[i]);
    }
    for(i=0; i < vector_terme_facteur.size(); i++)
    {
        cout << "vector_terme_facteur["<<i<<"]: " << vector_terme_facteur[i] << endl;
    }
 
    // vector_operateur 
    for(j=0; j < sizeof(tableau_operateur_calcul); j++)
    {
        vector_operateur.push_back(tableau_operateur_calcul[j]);
    }
    for(j=0; j < vector_operateur.size(); j++)
    {
        cout << "vector_operateur["<<j<<"]: " << vector_operateur[j] << endl;
    }
 
    // priorité a la multiplication
    for(j=0; j < vector_operateur.size(); j++)
    {
        if(vector_operateur[j]==2)
        {
            vector_terme_facteur[j] = vector_terme_facteur[j] * vector_terme_facteur[j+1];
            // supression de l element j+1 du vector_terme_facteur
 
            vector_terme_facteur.erase( vector_terme_facteur.begin()+(j+1));
            // supression de l element j+1 du vector_operateur
            vector_operateur.erase( vector_operateur.begin()+j);
        }
    }
 
    // verification suite multiplication
    cout << "verification de la multiplication" << endl;
    for(i=0; i < vector_terme_facteur.size(); i++)
    {
        cout << "vector_terme_facteur["<<i<<"]: " << vector_terme_facteur[i] << endl;
    }
    for(j=0; j < vector_operateur.size(); j++)
    {
        cout << "vector_operateur["<<j<<"]: " << vector_operateur[j] << endl;
    }
 
    // priorité a la division
    for(j=0; j < vector_operateur.size(); j++)
    {
        if(vector_operateur[j]==3)
        {
            vector_terme_facteur[j] = vector_terme_facteur[j] / vector_terme_facteur[j+1];
            // supression de l element j+1 du vector_terme_facteur
 
            vector_terme_facteur.erase( vector_terme_facteur.begin()+(j+1));
            // supression de l element j+1 du vector_operateur
            vector_operateur.erase( vector_operateur.begin()+j);
        }
    }
    // verification suite division
    cout << "verification de la division" << endl;
    for(i=0; i < vector_terme_facteur.size(); i++)
    {
        cout << "vector_terme_facteur["<<i<<"]: " << vector_terme_facteur[i] << endl;
    }
    for(j=0; j < vector_operateur.size(); j++)
    {
        cout << "vector_operateur["<<j<<"]: " << vector_operateur[j] << endl;
    }
 
    // priorité a la soustraction
    for(j=0; j < vector_operateur.size(); j++)
    {
        if(vector_operateur[j]==1)
        {
            vector_terme_facteur[j] = vector_terme_facteur[j] - vector_terme_facteur[j+1];
            // supression de l element j+1 du vector_terme_facteur
 
            vector_terme_facteur.erase( vector_terme_facteur.begin()+(j+1));
            // supression de l element j+1 du vector_operateur
            vector_operateur.erase( vector_operateur.begin()+j);
        }
    }
    // verification suite soustraction
    cout << "verification de la soustraction" << endl;    
    for(i=0; i < vector_terme_facteur.size(); i++)
    {
        cout << "vector_terme_facteur["<<i<<"]: " << vector_terme_facteur[i] << endl;
    }
    for(j=0; j < vector_operateur.size(); j++)
    {
        cout << "vector_operateur["<<j<<"]: " << vector_operateur[j] << endl;
    }    
 
    // priorité a l addition
    float sum = 0;
    for (i=0; i<vector_terme_facteur.size(); i++)
    {
        sum += vector_terme_facteur[i];
    }
    cout << "resultat final: " << sum;
 
	return 0;
 
}

30/06/2022, 20h03
koala01
Pas mal!!!

Cependant, il y a, en effet place pour du progrès :P. Car, pour être honnête, tu as énormément de chance que ton application ne plante pas lamentablement...

Allez, quelques conseils parmi d'autres:
1- (niveau : détail ) on n'inclut que les fichiers d'en-tête dont on a vraiment besoin
L'instruction préprocesseur #include <nom_de_fichier> ne fait, en définitive, que recopier (de manière récursive) le code qui se trouve dans le ficher indiqué là où l'instruction se trouve dans ton code à toi.

Or, tout ce code "rajouté" par le préprocesseur devra ... être analysé par le compilateur lorsqu'il prendra le relais. Et, bien sur, si tu n'utilises pas les fonctionnalités déclarées par le fichier inclus, tu feras tout simplement travailler le compilateur ... pour rien.

Cette analyse va prendre du temps. Beaucoup de temps. Tu vas donc demander au compilateur de prendre "beaucoup de temps" à faire un travail qui ne servira strictement à rien.

Ce n'est pas catastrophique ici, car le code reste malgré tout "très simple". Mais, dans les projets "très importants" (composés de plusieurs centaines de milliers de fichiers), cela peut représenter un temps supplémentaire pour la compilation absolument considérable. Il vaut donc mieux prendre directement l'habitude de n'inclure que "le stricte nécessaire", mais guère plus ;)

Tu n'utilises aucune des fonctionnalités fournies par les fichiers d'en-tête <regex>, <typeinfo>, <cassert> ou <list>. Tu n'as donc pas besoin de les inclure ici.

Par contre, tu n'as pas inclut le fichier d'en-tête <vector>, qui apporte la classe std::vector que tu utilises. Par chance, il semblerait que ce fichier soit inclut de manière récursive par l'un des fichiers "inutiles" que tu as inclut, tout en rajoutant une quantité considérable de code "en trop" :P

Les seuls fichiers dont tu aurais besoin ici sont, en définitive:
- <iostream> pour std::cout
- <string> pour la classe std::string (et la fonction std::stof)
- <vector> pour la classe std::vector
- et <numeric> pour la fonction std::accumulate
Eventuellement, si tu décidais d'utiliser les assertions (assert(condition_a_vérifier)) tu pourrais envisager d'ajouter le fichier <cassert à cette liste ;)
2- (niveau : détail ) Les commentaires qui ne font que paraphraser ce que le code indique déjà sont totalement inutiles:

Ainsi, tes commentaire // copie du string et // <=> std::string copie_de_str = str; sont totalement inutile, car ils ne font que répéter (deux fois, qui plus est !!! ) ce que le code std::string copie_de_str {str}; dit déjà de manière très claire, d'autant plus que tu as eu le bon ton de choisir un nom pour la variable qui soit particulièrement explicite :D

Par contre, le commentaire // remplacer les , par des . est d'une certaine manière "plus intéressant", car il décrit non pas ce que ton code fait,mais ce que tu cherches à faire avec le code qui suit.

Si donc, le troisième commentaire semble (relativement justifié), les deux premiers auraient parfaitement pu ne pas avoir été écrits car ils n'apportent rien de "particulièrement intéressant" ;)

Le commentaire suivant (// savoir la position du "premier caractère n'ayant pas été utilisé par la fonction) est encore plus intéressant pour mon explication car il se trouve "entre les deux" situations que nous venons de croiser:

D'une part, il indique clairement l'usage que tu veux faire de la variable position, tout en ne paraphrasant pas "tout à fait" le code qui le suit.

Peut-être aurais tu pu éviter ce commentaire en choisissant "un autre nom" pour la variable :question: Peut être aurait il "simplement" suffit de rajouter "quelque chose" au nom "position" pour rendre ce commentaire tout à fait inutile :question:

La même remarque pourrait d'ailleurs s'appliquer au commentaire // longueur de la chaine restante.

3- (niveau : détail) la directive using namespace std; n'a rien à faire ici
n'ayant pas trop envie de répéter "une fois encore" la raison de cette remarque, je te proposerais simplement d'aller lire ==>cette intervention<== de ma part qui explique clairement pourquoi il ne faut pas l'utiliser.

Dans le cas présent, c'est d'autant plus vrai que tu ne profites même pas de la "facilité" apportée par cette directive, vu que tu utilises déjà correctement le nom pleinement qualifié de la plupart les fonctionnalités offertes par la bibliothèque standard, à savoir:
- std::string
- std::stof
- std::vector
Au final, il n'y a guère que pour cout (qui devrait être std::cout) et pour endl (qui devrait être std::endl) que tu utilise cette possibilité.

L'un dans l'autre, il faudrait de toutes manières essayer "d'homogénéiser" les pratiques: ou bien, tu utilises le nom pleinement qualifié pour tout, ou bien tu profite de la facilité offerte par la directive using namespace std;. Mais il faut être "un tout petit peu cohérent" dans ce que l'on fait, et ne pas commencer à utiliser une possibilité pour "certaines choses" et l'autre "pour le reste" ;)

(Tu auras compris à quelle solution va ma préférence personnelle :D )

4- (niveau : critique) Pas d'allocation dynamique de la mémoire manuelle s'il n'y a pas d'héritage public

Et encore: même lorsqu'il y a un héritage public, il y a moyen de se passer de l'allocation dynamique de la mémoire manuelle dans certaines circonstances.

Et si les circonstances font qu'il est vraiment impossible de se passer de l'allocation dynamique de la mémoire, il est impératif de savoir ce que l'on fait et de s'entourer d'énormément de précautions pour éviter que cela ne tourne à la catastrophe.

C++ fournit amplement assez de fonctionnalités que pour pouvoir élever cette simple phrase en règle générale qui devrait être respectée de tous temps, sauf situation vraiment particulière.

La meilleure preuve en est que tu as d'ailleurs malheureusement "tout faux" dans la manière dont tu l'utilises:
a- La chaîne que tu essaye d'analyser est composée de neuf facteurs et de huit opérateurs, mais tu essayes de faire rentrer "toutes ces données" dans l'espace demandé au système d'exploitation (au travers de new) suffisant pour représenter ... une seule (et unique !!!) donnée. Comment comptes tu t'y prendre pour faire rentrer toutes ces données dans un si petit espace :question: au chausse-pied :question:

Quand on demande au système d'exploitation de nous allouer de la mémoire (au travers de new), on prend la responsabilité de rendre cette mémoire au système d'exploitation quand on n'en a plus besoin. Si on perd la variable (de type pointeur) représentant l'adresse de la mémoire en question avant de l'avoir rendue a système d'exploitation, on observe une "fuite mémoire": cette mémoire ne pourra plus être utilisée par l'application en cours (vu qu'on ne sait plus y accéder) alors que le système d'exploitation continue à considérer cette mémoire comme "inutilisable" de son point de vue (vu qu'elle est toujours considérée comme "utilisée par l'application").

Si le cas se reproduit "suffisamment souvent", on peut carrément en arriver à un point où le système d'exploitation ne dispose plus d'assez de mémoire que pour assurer son propre travail (car lui aussi, il a besoin de mémoire pour travailler), et c'est donc "tout le système" qui risque de s'effondrer à un moment ou à un autre.

Dans le cas présent, tu as de la chance: ton application ne va pas tourner "pendant des heures", et le système d'exploitation récupérera "par la porte ou par la fenêtre" toute la mémoire qu'il a allouée à l'application lorsque celle-ci s'arrêtera

Le "peut de mémoire" que l'on perd ne sera donc pas perdu pendant très longtemps. Tu auras cependant compris que c'est le genre d'erreur que l'on ne peut pas se permettre de laisser passer, car, si tu en viens à la reproduire "à peine plus souvent", dans un code "à peine plus complexe", pour une application qui devra travailler pendant "à peine plus longtemps" (mettons: quelques heures ou quelques jours), ce sera une véritable catastrophe.

C'est d'autant plus vrai que tes variables tableau_terme_facteur et tableau_operateur_calcul ne servent en réalité absolument à rien, vu y introduit "au chausse-pied" des données qui correspondent à celles que tu récupère au travers des variables extracted_terme_facteur et extracted_operateur_calcu dans le seul but ... d'attendre que tu te décides "enfin (!!) " à les ajouter à tes tableaux de type std::vectorMais, alors, pourquoi pas directement ajouter les valeurs de extracted_terme_facteur et de extracted_operateur_calcu respectivement dans vector_terme_facteur et vector_operateur :question:

5- (niveau: danger) sizeof ne fait pas ce que tu crois

Au vu de ton utilisation que tu en fais, je suis quasiment persuadé (même si je peux me tromper) que tu penses te renvoie "comme par magie" le nombre d'éléments auxquel un pointeur ( comme extracted_terme_facteur ou extracted_operateur_calcul) donne accès.

Ce n'est absolument pas le cas!!!

l'opérateur sizeof nous renvoie le nombre de bytes (d'octets) qui est nécessaire pour permettre de représenter l'intégralité d'une donnée quelconque.

Dans le cas présent, si sizeof(extracted_terme_facteur[) te renvoie 8, c'est uniquement parce que extracted_terme_facteur est un pointeur (sur une donnée de type float, en l'occurrence) et qu'un pointeur est en réalité une valeur numérique entière, généralement non signée, dont la taille (le nombre de bytes / d'octets) qui la compose permet permet de représenter l'ensemble des adresses mémoire (potentiellement) accessibles sur le système sur lequel l'application s'exécute.

Tu utilises, de toute évidence, une architecture 64 bits. Cela implique que le type "pointeur" est composé de ... 8 bytes (ou octets).

6- (niveau: détail) Evites les instructions inutiles

On a tout à perdre à ajouter des instructions inutiles:
- cela nous prend du temps pour les écrire
- cela prend du temps au compilateur pour les analyser et en fournir le code binaire exécutable correspondant
- cela prend du temps au processeur pour exécuter ces instructions lorsque le programme fonctionne
- cela augment (grandement) le risque d'erreurs et de bugs
- cela rend le code plus complexe, qui demande de ce fait plus de temps afin de l'analyser
- cela rend le code plus difficile à comprendre, et, le cas échéant, à corriger / faire évoluer
Car, comme l'avait si bien décrit le créateur de la 2CV: ce qui est absent ne peut pas casser ;)

Toute la partie dans laquelle tu stocke provisoirement les valeurs de extracted_terme_facteur et extracted_operateur_calcu dans (respectivement) tableau_terme_facteur et tableau_operateur_calcul avant de les stocker dans vector_terme_facteur et vector_operateur est inutile, et, en plus, à l'origine d'un bug majeur (à cause de la mauvaise utilisation que tu fait de new)

Retiens qu'un code sera plus souvent lu / analysé / corrigé qu'il ne sera compilé et / ou exécuté. Cela signifie que le premier interlocuteur auquel ton code est destiné n'est pas le compilateur, mais bien ... l'humain qui doit le lire.

Le compilateur sera suffisamment buté et manquera suffisamment d'imagination que pour t'indiquer clairement ce qu'il ne comprend pas, alors que l'humain qui doit lire ton code pourrait arriver à en tirer des conclusions qui ne sont pas celles auxquelles tu pensais toi-même.

Plus tu peux garder ton code simple, plus tu limite le risque d'erreur et de mauvaise compréhension.

En un mot, une certaine forme de développement utilise l'acronyme KISS : Keep It Simple, Stupid (garde cela simple, idiot). Voilà bien une "règle générale" supplémentaire à respecter en tous temps (et sans aucune situation particulière ;) )

7- (niveau: important) Limite la taille des fonctions

Il fut un temps où les règles en entreprise ne se gênaient pas pour imposer une limite de cinquante ligne grand maximum par fonction. La raison "officielle" -- et la plus facilement défendable -- pour cette limite était liée aux limites des possibilités d'affichage de l'époque, car on disposait royalement de 25 lignes par 80 colonnes, et que cette limite autorisait déjà le fait d'avoir besoin de ... deux fois la surface d'affichage disponible pour (avoir une chance de) lire le contenu de l'ensemble de la fonction. Ce qui compliquait d'ailleurs déjà fortement la relecture du code :?

Bien sur, les évolutions successives ont rendu cette contrainte matérielle obsolète. Et pourtant le problème persiste: lorsqu'une fonction est "trop grande", il devient très rapidement difficile de l'analyser "correctement".

Je ne vais pas donner de limite "gravée dans le marbre" quant à la taille maximale des fonctions, car je suis persuadé qu'elle risquerait de t'inciter à avoir recours à de nombreuses techniques que je qualifierais de discutables pour arriver à respecter cette limite.

Cependant, je considère généralement qu'une fonction qui ferait plus de 25 à 30 lignes (à peu près) est une fonction qui est déjà "trop longue".

Alors, évidemment, quand je vois ta fonction main qui fait 200 lignes (commentaires compris, je te l'accorde), j'ai peur :P

Les prochaines remarques devraient te permettre de résoudre "assez facilement" le problème ;)

6- (niveau: important) SRP : Single Responsability Principle (ou "Principe de la Responsabilité Unique)

L'un des principes les plus importants et les plus immuable de la programmation, quel que soit le paradigme ou le langage utilisé, est très certainement le principe connu sous l'acronyme SRP, qui est l'abréviation anglaise de Single Responsability Principle (ou principe de la responsabilité unique).

Ce principe nous dit -- pour faire simple -- que chaque "chose", chaque type de donnée, chaque donnée et chaque fonction ne devrait jamais avoir qu'une seule et unique responsabilité. Si "quelque chose" (une fonction, par exemple) se retrouve à avoir plus d'une seule (et unique) responsabilité, c'est que cette chose "en fait trop".

A ce titre, ta fonction main en fait, décidément, beaucoup trop, car, elle s'occupe:
1. (plusieurs) fois de l'affichage d'informations relatives à son "état d'avancement courant"
2. de l'extraction (et du stockage temporaire) des termes et des opérateurs qui composent la chaîne de caractères
3. de la copie des termes et opérateurs "temporaires" dans les tableaux "finaux"
4. du calcul des produits des multiplications
5. du calcul des quotients des divisions
6. du calcul des sommes des additions
7. du calcul des différence des soustractions.
8. de l'affichage final
cela nous fait donc huit responsabilités. Si même on considère que les responsabilités (2) et (3) peuvent aisément être réunies en une seule, ainsi que les responsabilité (5),(6) et (7), et en considérant comme "logique" que la responsabilité (8) est "inhérente" à la fonction principale, il reste malgré tout encore quatre responsabilités, ce qui en ferait au moins deux de trop...

8- (niveau: conseil) L'affichage ne sert pas au débuggage

Une grande partie de ton code ne sert qu'à afficher l'état actuel de ton programme. Ce n'est la la "bonne manière" de débugger. Tu serais bien inspiré de t'intéresser à un outil génial qui t'a été fourni avec ton compilateur: le débuggeur, ainsi qu'à son utilisation.

Il permet souvent de se faire une idée bien plus correcte de ce qui se passe en mémoire (sans risque de se méprendre sur la signification de la valeur renvoyée par sizeof(), par exemple ;) )

Cela réduirait en outre considérablement la taille de ton code ;)

9- (niveau : détail) Les valeurs énumérées, c'est pas fait pour les chiens!

Si je passe mon temps à définir une énumération et une fonction qui renvoie justement une de ces valeurs énumérées en fonction du caractère que l'on a rencontré, ce n'est pas juste pour m'amuser ni pour faire joli...

C'est parce que les termes "addition", "soustraction", "multication" ou "division" sont beaucoup plus explicite que les valeurs numériques qui y sont associées.

Pourquoi ne pas avoir utilisé ces termes pour les tests que l'on retrouves aux lignes 151, 176 et 200 :question: ce serait beaucoup plus clair pour la personne qui lirait le code, et le compilateur comprendrait tout aussi bien ;)

La cerise sur le gâteau étant que, si un jour, je décidais de mettre les termes dans un ordre différent ou même d'associer des valeurs numériques spécifiques à ces termes (par exemple 1 pour addition, 2 pour soustraction, 4 pour multiplication et 8 pour division), je n'aurais même plus besoin de modifier le code ailleurs ;)

En conclusion

Toutes ces remarques devraient déjà te permettre d'améliorer énormément ton code, et même, de manière indirecte, de le rendre "plus générique", quel que soit le sens que tu donnes à cette expression.

J'aurais pu entrer dans énormément de détails supplémentaires, mais, au vu de la longueur de cette réponse, j'aurais couru le risque que le système la refuse une fois de plus car "elle contient plus de caractères qu'on ne peut en mettre en base de donnée".

N'hésites pas à demander des précisions sur les points que j'aurais décidément trop effleurés ;)
30/06/2022, 22h45
Mat.M

Citation:

Envoyé par binco

Comment faire pour calculer l'opération?

Peut-être qu'un "parser" d'expression serait utile ?
En voilà un excellent que j'utilise sur mon projet source sur GitHub
01/07/2022, 15h59
binco

merci beaucoup ça fonctionne