Discussion :

[Iyoxa]

Bonjour,

Je suis actuellement étudiant en BTS 1ère année en SNIR. Je suis encore en train d'apprendre le C++ et je rencontre un problème que je n'arrive pas à corriger.

Actuellement, nous voyons les surcharges des opérateurs, j'ai réussi quasiment entièrement l'exercice, mais il y a une erreur que je n'arrive pas à corriger.

Énoncé :

On vous demande créer une classe GrandEntier qui permet de traiter tous les chiffres significatifs d'un nombre
entier positif de 64 chiffres.
Cette classe possédera une surcharge sur
- l'opérateur << qui permettra l'affichage d'un objet GrandEntier.
- l'opérateur + qui permettra l'addition de deux objets GrandEntier.
Après avoir complété le sujet et décommenté les parties correspondantes dans le fichier Application.cpp, vous
devriez obtenir la sortie suivante :
n1 vaut: 12345
n2 vaut: 5671234
n3 vaut: 999999999999999999999999999999999999999999999999999999999999999
n4 vaut: 1
n5 vaut: 0
12345 + 5671234 = 5683579
999999999999999999999999999999999999999999999999999999999999999 + 1 =
1000000000000000000000000000000000000000000000000000000000000000
12345 + 9 = 12354
5671234 + 10000 = 5681234

-> De mon côté, j'ai tout réussi sauf ceci :

999999999999999999999999999999999999999999999999999999999999999 + 1 =
1000000000000000000000000000000000000000000000000000000000000000

En effet, avec mon programme j'obtiens :

999999999999999999999999999999999999999999999999999999999999999 + 1 =
000000000000000000000000000000000000000000000000000000000000000

(Il me manque donc le 1 devant...)

Le résultat actuel avec le programme :
Si vous souhaitez télécharger l'archive : https://www.mediafire.com/file/b8ht6...3-POO.zip/file
Merci d'avance aux personnes qui pourront m'aider

Cordialement,

Voici le programme :

Application.h

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
#ifndef APPLICATION_H
#define APPLICATION_H
#include <cstdlib>
#include "IHM.h"
 
 
class Application
{
    public:
        Application();
        ~Application();
    protected:
    private:
        void Run();
        IHM m_ihm;
};
 
#endif // APPLICATION_H

Application.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
#include "Application.h"
#include "GrandEntier.h"
 
Application::Application()
{
    Run();
}
 
Application::~Application()
{
    TRACE_ONLY(m_ihm.AfficheMessage("Fin application...\n",MAGENTA);)
}
 
void Application::Run()
{
    TRACE_ONLY(m_ihm.AfficheMessage("Run...\n",MAGENTA);)
    GrandEntier n1(12345), n2( 5671234 ),
           n3("999999999999999999999999999999999999999999999999999999999999999"),
           n4( "1" ), n5;
 
    cout << "n1 vaut: " << n1 << endl
        << "n2 vaut: " << n2 << endl
        << "n3 vaut: " << n3 << endl
        << "n4 vaut: " << n4 << endl
        << "n5 vaut: " << n5 << endl << endl;
 
    n5 = n1 + n2;
    cout << n1 << " + " << n2 << " = " << n5 << endl << endl;
 
    cout << n3 << " + " << n4 << " = " << endl
        << ( n3 + n4 ) <<  endl << endl;
 
    n5 = n1 + 9;
    cout << n1 << " + " << 9 << " = " << n5 <<  endl << endl;
 
    n5 = n2 + "10000";
    cout << n2 << " + " << "10000" << " = " << n5 << endl;
}

GrandEntier.h

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
#ifndef GRANDENTIER_H
#define GRANDENTIER_H
#define MAX 64
#include <iostream>
#include <cstdlib>
#include <string>
 
using std::ostream;
 
class GrandEntier
{
public:
    GrandEntier( long long = 0 );                 // constr. conversion/par défaut.
    ~GrandEntier();
    GrandEntier( const char * );             // constructeur de conversion.
 
    friend ostream& operator << (ostream&, const GrandEntier&);
    GrandEntier operator + (const GrandEntier &nb);
    GrandEntier operator + (const char* &str);
private:
    unsigned int m_NbrChiffres;
    unsigned int m_Nombre[MAX];
    void DecompositionLong(long long variable);
    void DecompositionChar(const char *chaine);
    void Permutation();
};
 
#endif // GRANDENTIER_H

GrandEntier.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
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
#include "GrandEntier.h"
#include <cstring>
#include <string.h>
// Constructeur de conversion.
GrandEntier::GrandEntier( long long val )
{
    DecompositionLong(val);
}
 
GrandEntier::GrandEntier( const char *chaine )
{
    DecompositionChar(chaine);
}
 
GrandEntier::~GrandEntier()
{
    //dtor
}
 
void GrandEntier::DecompositionLong(long long variable)
{
    for(int i=0;i<MAX;i++)
    {
        m_Nombre[i]=0;
    }
    unsigned int j = 0;
    do
    {
        m_Nombre[j] = variable%10;
        variable = variable/10;
        j++;
    }
    while(variable > 0);
    m_NbrChiffres = j;
}
 
void GrandEntier::DecompositionChar(const char *chaine )
{
    for(int i=0;i<MAX;i++)
    {
        m_Nombre[i]=0;
    }
    unsigned int j =0;
    do
    {
        m_Nombre[j] = (int)chaine[j] -48;
        j++;
    }
    while((chaine[j] != NULL));
    m_NbrChiffres = j;
    Permutation();
}
 
void GrandEntier::Permutation()
{
    int permut = 0;
    for(int i=0;i<(m_NbrChiffres/2);i++)
    {
        permut= m_Nombre[i];
        m_Nombre[i] = m_Nombre[(m_NbrChiffres-1)-i];
        m_Nombre[(m_NbrChiffres-1)-i] = permut;
    }
}
 
 
ostream& operator << (ostream& ostr , const GrandEntier& NB)
{
    for(unsigned int i=0;i < NB.m_NbrChiffres ;i++)
    {
        ostr<< NB.m_Nombre[(NB.m_NbrChiffres-1)-i];
    }
    return ostr;
}
 
GrandEntier GrandEntier::operator + (const GrandEntier &nb)
{
    GrandEntier retour;
    for(int i=0; i< MAX; i++)
    {
        retour.m_Nombre[i]=((this->m_Nombre[i])+(nb.m_Nombre[i]));
    }
    retour.m_NbrChiffres = this->m_NbrChiffres;
    if(nb.m_NbrChiffres > retour.m_NbrChiffres)
    {
        retour.m_NbrChiffres = nb.m_NbrChiffres;
    }
    for(int i=0; i< MAX; i++)
    {
        if(retour.m_Nombre[i] >=10)
        {
            retour.m_Nombre[i]=(retour.m_Nombre[i]-10);
            if(i<MAX)
            {
                retour.m_Nombre[i+1] = (retour.m_Nombre[i+1])+1;
                if(retour.m_NbrChiffres<(i+1))
                {
                    retour.m_NbrChiffres = (i+1);
                }
            }
        }
    }
    return retour;
}
 
GrandEntier GrandEntier::operator + (const char* &str)
{
    GrandEntier na (str);
    GrandEntier nb;
    for(int i=0; i< MAX; i++)
    {
        na.m_Nombre[i]= (this->m_Nombre[i]);
    }
    na.m_NbrChiffres = this->m_NbrChiffres;
    return (na+nb);
}

IHM.h

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
#ifndef IHM_H
#define IHM_H
 
// affichage trace
#define TRACE
#if defined(TRACE)
    #ifndef TRACE_ONLY
      #define TRACE_ONLY(x) x
    #endif
#else
    #ifndef TRACE_ONLY
      #define TRACE_ONLY(x)
    #endif
#endif
 
// couleur texte
#define RESET   "\033[0m"
#define NOIR    "\033[30m"
#define ROUGE   "\033[31m"
#define VERT    "\033[32m"
#define JAUNE   "\033[33m"
#define BLEU    "\033[34m"
#define MAGENTA "\033[35m"
#define CYAN    "\033[36m"
#define BLANC   "\033[37m"
 
#include <string>
using namespace std;
class Equipe;
 
class IHM
{
    public:
        IHM();
        ~IHM();
        string SaisieChaine(string question);
        unsigned int SaisieUnsignedInt(string question);
        void AfficheMessage(string message,string couleur=BLANC);
    protected:
    private:
};
 
#endif // IHM_H

IHM.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
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
#include <iostream>
using namespace std;
#include "IHM.h"
#include <sstream>
 
 
IHM::IHM()
{
    //ctor
}
 
IHM::~IHM()
{
    //dtor
}
 
string IHM::SaisieChaine(string question)
{
    string chaine;
    cout << question;
    getline(cin,chaine);
    return chaine;
}
 
unsigned int IHM::SaisieUnsignedInt(string question)
{
    unsigned int ens;
    int nombre;
    string snombre;
    istringstream iss;
    bool conversionOK=false;;
    // on oblige l'utilisateur à saisir un nombre entier positif
    do
    {
        cout << question;
        // on saisie une chaîne
        getline(cin,snombre);
        // on vérifie qu'il n'y a pas d'espaces dedans
        if (snombre.find(" ")==string::npos && snombre.find(",")==string::npos && snombre.find(".")==string::npos)
        {
            iss.clear();
            iss.str(snombre);
            // on convertit en entier
            if (iss>>nombre)
                // on vérifie qu'il est positif
                if (nombre >= 0)
                {
                    conversionOK=true;
                    ens=nombre;
                }
        }
    }
    while (!conversionOK);
    return ens;
}
 
void IHM::AfficheMessage(string message,string couleur)
{
    cout << couleur <<message<<RESET;
}

main.cpp

Code :

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

1
2
3
4
5
6
7
8
9
#include <iostream>
using namespace std;
#include <Application.h>
 
int main()
{
    Application MyApp;
    return 0;
}

EDIT :

Merci à @Winjerome qui m'a aidé pour résoudre le problème !

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
 
GrandEntier GrandEntier::operator + (const GrandEntier &nb)
{
    GrandEntier retour;
    for(int i=0; i< MAX; i++)
    {
        retour.m_Nombre[i]=((this->m_Nombre[i])+(nb.m_Nombre[i]));
    }
    retour.m_NbrChiffres = this->m_NbrChiffres;
    if(nb.m_NbrChiffres > retour.m_NbrChiffres)
    {
        retour.m_NbrChiffres = nb.m_NbrChiffres;
    }
    for(int i=0; i< MAX; i++)
    {
        if(retour.m_Nombre[i] >=10)
        {
            retour.m_Nombre[i]=(retour.m_Nombre[i]-10);
            if(i+1 < MAX)
            {
                retour.m_Nombre[i+1] = (retour.m_Nombre[i+1])+1;
                if (retour.m_NbrChiffres<i+2)
                {
                    retour.m_NbrChiffres = (i+2);
                }
            }
        }
    }
    return retour;
}

[dalfab]

Bonjour,

Ligne 94 de GrandEntier.cpp, tu incrémentes le chiffre à l'indice [i+1], donc ton nombre a au moins i+2 chiffres.

[Iyoxa]

Bonjour,

Merci pour votre réponse !
J'ai pu voir ceci avec @Winjerome sur discord, il m'a beaucoup aidé merci! Le problème est désormais résolu (j'ai ajouté au sujet principale la réponse)

Cordialement,

[dalfab]

Si les nombres sont sensés avoir 64 chiffres, ça n'a aucun sens d'y afficher un nombre de 65 chiffres! La solution correcte serait le résultat "nombre trop grand"

[Bousk]

Normalement ce genre d'exercice nécessite de stocker le nombre dans une chaîne de caractères puis faire les opérations à l'ancienne avec propagation de la retenue.
Utiliser un unsigned int m_Nombre[MAX]; me semble abusif et pas acceptable. Est-ce que le correcteur a validé cet usage ?