Problème d'opérateur de classe

Version imprimable

Bonjour,

Ça fait un moment que je planche sur le problème, mais je n'arrive pas à m'en défaire. Avant toute remarque voici mon code source:

fichier de la classe:

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
#include "Entier.h"
 
Entier::Entier(std::string a): m_nombre(a), std::string()
{
    std::cout << a << std::endl;
} 
 
Entier::Entier(): m_nombre(""), std::string()
{}
 
Entier& Entier::operator+=(const Entier& nombre2)
{
    int i, retenue=0, tmp, taille, nb1, nb2;
    for(i=0; i<(taille=std::max(nombre2.size(), m_nombre.size())); i++)
    {
	nb1=m_nombre[i]-'0';
	std::cout << "nb1=" << m_nombre[i] << std::endl;
	nb2=nombre2[i]-'0';
	std::cout << "nb2=" << nombre2[i] << std::endl << "taille=" << nombre2.size() << std::endl;
	if((tmp=nb2+nb1+retenue)>=10)
	{
	    retenue=1;
	    tmp=tmp-10;
	    std::cout << "m_nombre[i]=" << m_nombre[i] << std::endl; 
	    m_nombre[i]=((char)tmp+'0');
	    retenue=0;
	    std::cout << m_nombre[i] << std::endl;
	}
	else
	{
	    retenue=0;
	    m_nombre[i]=((char)tmp+'0');
	    std::cout << m_nombre[i] << std::endl;
	}
    }
    if(taille>m_nombre.size())
    {
	for(; i<taille; i++)
	{
	    m_nombre.push_back(nombre2[i]);
	    nb1=m_nombre[i]-'0';
	    nb1++;
	    m_nombre[i]=((char)nb1+'0');
	}
 
    }
    return *this;
}
 
Entier operator+(Entier const& a, Entier const& b)
{
    Entier copie(a);
    copie+=b;
    return copie;
}

fichier header

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
#include <cstring>
#include <iostream>
#include <stdio.h>
#include <stdlib.h>
 
class Entier : public std::string
{
    public:
	Entier();
	Entier(std::string);
	Entier& operator+=(Entier const& nombre2);
 
    private:
	std::string m_nombre;
};
 
Entier operator+(Entier const&, Entier const&);

Fichier main

Code:

1
2
3
4
5
6
7
8
9
10
11
#include <iostream>
#include "Entier.h"
 
using namespace std;
 
int main(int argc, const char *argv[])
{
        Entier nb1("333");
        Entier nb2("666");
        nb1+nb2;
}

Ainsi, dans la méthode operator+= lorsque j'affiche nombre2[i], il n'affiche rien du tout(juste un espace blanc) et lorsque je souhaite afficher la taille, il indique tout simplement 0.

Merci de toutes réponses

02/06/2012, 20h47
screetch

c'est parce que tu dérives de std::string ET que u contiens un std::string. Ce n'est pas interdit en soit, mais ca veut dire que ton objet a un comportement de std::string, tout en contenant un std::string, c'est très confusant :)

la preuve: lorsque tu utilises nombre2[i] tu utilises l'heritage, alors que lorsque tu utilises m_nombre[i] tu utilises le membre.

retire l'heritage; il est inutile.

Je regarde ton code, j'éditerais au fur et à mesure.

Code:

1
2
 
for(i=0; i<(taille=std::max(nombre2.size(), m_nombre.size())); i++)

Tu va recalculé ceci à chaque tour de boucle, il vaut mieux faire :

Code:

1
2
3
 
int taille = std::max(nombre2.size(), m_nombre.size());
for(i=0; i< taille; i++)

C'est déjà plus lisible.

i++ enregistre la valeur de i, incrémente i puis retourne la valeur enregistrée. Il faut faire ++i c'est plus rapide.

On va plutôt tenter d'accéder directement aux données private de nombre2, c'est plus rapide et sans risque (vu qu'il est passé par référence constante)

Au niveau de l'opérateur += je te conseillerais de changer d’algorithme :

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
 
int taille_nb1 = m_nombre.size();
int taille = std::min(nombre2.m_nombre.size(), taille_nb1);
int a = 0;
 
for(int i=0; i < taille; ++i)
{
         a += nombre2.m_nombre[i] + m_nombre[i];
         m_nombre[i] = a%10;
         a /= 10;
}
 
if(nombre2.m_nombre.size() > taille_nb1 )
{
         int taille_bis = nombre2.m_nombre.size();
         for( ; taille < taille_bis; ++taille)
         {
                 a+= nombre2.m_nombre[i];
                 this->push_back(a%10);
                 a /= 10;                 
          }
}
while(a != 0)
{
          if(taille_nb1 == taille)
          {
                  m_nombre.push_back(a);
                  a = 0;
           }
           else
           {
                 a+= m_nombre[i];
                 m_nombre[i] = a%10;
                 a /= 10;            
            }
}

Je pense que c'est plus rapide et plus clair.

02/06/2012, 22h56
ScriptorTux

Bonjour,

Je vous remercie de vos réponses, je n'ai encore malhereusement pas encore eu le temps de tester, mais je vous tiens au courant dès que ce sera fait.

Et merci beaucoup aussi pour la proposition d'amélioration de l'algo :mrgreen:

Merci encore ;)

Salut,

Déjà, c'est une très mauvaise idée que d'hériter de std::string, car elle ne expose un destructeur public et non virtuel.

Sans oublier le fait que la classe std::string a, classiquement, sémantique de valeur, alors que l'héritage se fait avec des classe ayant sémantique d'entité ;)

De plus, la classe std::string expose tout un tas de fonctions qui, de prime abord, sont incompatible avec la sémantique que l'on pourrait attendre de la part d'une classe nommée "Entier".

Parmis celles-ci, comptons, par exemple, la fonction append, qui ne veut strictement rien dire pour un entier (ben oui, cela signifie que, nombre("9").append("6") nous donnerait... "96" :aie:).

En outre l'opérateur += est déjà défini pour la classe std::string et équivaut, justement, à cette fonction append, alors que, personnellement, si j'ai une classe Entier et que je fais monEntier += 6, je m'attend honnêtement à ce qu'il vaille 15 (et non 96) si, au départ, il valait 9 ;)

Enfin, je présumes que tu prévois de pouvoir effectuer des opérations mathématiques sur ton entier (au minimum les quatre opérations de base :D), hors, le maintien d'une chaine de caractères représentant ton entier n'est, très clairement, pas la meilleure manière d'y arriver ( re :aie:)

Ta classe "entier" me semble d'autant plus inutile que la STL fournit dés le départ tout ce qu'il peut te falloir pour convertir une chaine de caractères en entier et inversément, au pire, tu pourrais te contenter de recréer des fonctions libres proches de
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 int stringToInt(std::string const & str) { std::stringstream ss; ss<< str; int result; ss>> result; return result; } std::string intToStr(int value) { std::stringstream ss; ss<< value; return ss.str(); }
Tu pourrais alors travailler simplement avec tes entiers tant qu'il est besoin de les manipuler (comprends : d'y appliquer les quatre opérations de base) et utiliser ces deux fonctions toutes simples lorsque tu te retrouves face au besoin de les convertir en chaines ou, à l'inverse de convertir une chaine de caractères en entier ;)

EDIT : Enfin, n'oublie pas que les flux standard (i/o fstream, cin/cout) sont parfaitement capable de s'occuper de la conversion... Ces deux fonctions ne devenant donc utiles que dans quelques cas très particuliers ;))

Bonjour,

Alors je souhaite avant tout m'excuser en toute sincérité du retard de cette réponse .

Il y a quand même une bonne nouvelle , grâce à vous j'ai réussi à résoudre mon problème .

J'ai passé du temps sur mon code en prenant soin de prendre vos commentaires en compte et j'ai retravaillé mon algorithme, que je présente ci-dessus pour ceux que ça intéresse:
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 Entier& Entier::operator+=(const Entier& nombre2) { int taille_nb1 = m_nombre.size(), i, taille_nb2=nombre2.m_nombre.size(); int a = 0; if(taille_nb1 >= taille_nb2) { int i=taille_nb1-1, i2=taille_nb2-1; for(;i2 >= 0;i2--, i--) { a+=(nombre2.m_nombre[i2]-'0')+(m_nombre[i]-'0'); m_nombre.replace(i,1,1,(( a%10 )+'0')); a/=10; } for(;i>=0;i--) { a+=(m_nombre[i]-'0'); m_nombre.replace(i,1,1,(a%10)+'0'); a/=10; } } else { int i=taille_nb1-1, i2=taille_nb2-1; for(;i>=0;i--,i2--) { a+=(nombre2.m_nombre[i2]-'0')+(m_nombre[i]-'0'); m_nombre.replace(i,1,1,(( a%10 )+'0')); a/=10; } for(; i2>=0; i2--) { a+=(nombre2.m_nombre[i2]-'0'); m_nombre.insert(0,1,(a%10)+'0'); a/=10; } } if(a!=0) m_nombre.insert(0,1,'1'); std::cout << "m_nombre=" << m_nombre << std::endl; return *this;
Évidemment je sais qu'il est améliorable, mais pour l'instant il marche et c'est déjà un grand pas.

Merci encore énormément .