Argh! Problème de constructeur de recopie et de surdéfinition de =Résolu

Question

Ca fait une semaine que j'eesaye de comprendre ce bug, mais rien n'y fait 

(et je me sent tout frustr&#233; du coup , je dors plus, je mange plus, je bois plus  ('fin non quand m&#234;me pas...))



A la base, je fais une classe sur les matrices, mais je ne vais pas vous fournir celle-l&#224; car ce serait bien long...

Mais j'ai fait (sp&#233;cialement pour vous ) une autre classe, qui fonctionne sur le m&#234;me principe et qui a le meme probl&#232;me de compilation...



Voici la classe bugu&#233;e:





class A

{

    int a;

public:

    A() 

    {

        a= 0;

    }

     int  get_value() 

    {

        return a;

    }

    void set_value(int new_a)

    {

        a =new_a;

    }

    A operator+(A& other)

    {

        A sum;

        sum.set_value(this->get_value() + other.get_value());

        return sum;

    }

    A& operator= (A& other) 

    {

         this ->set_value(other.get_value());

        return *this;

    }

};





Immaginons que mon main() soit



int main()

{

    A a,b,c;

    a.set_value(1);

    b.set_value(36);

    c.set_value(42);

    a  = b+c;

    return 0;    

}



Alors il ne compile pas la ligne en rouge, et me dit:

Error: no match for 'operator' in 'a A::operator+(A&)((&c))

Error: Candidates are: A& A::operator=(A&)



Je comprend pas trop ce qu'il me veut , mais il est pas content le compilo !





Alors j'ai pens&#233; faire ceci:



 class  A

{

    int a;

    bool tampon;

public:

    A() 

    {

        a =0;

        tampon =   false; 

    }

    int get_value() 

    {

        return a;

    }

    void set_value(int new_a)

    {

        a =new_a;

    }

    A& operator+(A& other)

    {

        A* sum =   new  A;

        sum->tampon  = true;

        sum->set_value(this->get_value() + other.get_value());

        return *sum;

    }

    A& operator= (A& other) 

    {

         this ->set_value(other.get_value());

        if(other.tampon)

        delete &other;

        return *this;

    }

};





Mais malgr&#233; ma courte exp&#233;rience en
programmation, ca me semble assez laid, on dirait du bricolage. Et en
plus si un gugus d'utilisateur (en l'occurence moi ) s'amuse &#224; &#233;crire:

A a,b;

a.set_value(1);

b.set_value(2);

while(1)

{

    a+b;

}

La m&#233;moire explose, car la matrice de r&#233;sultat de a+b n'est pas d&#233;truite.





On m'a aussi propos&#233; ceci, mais qui comporte le m&#234;me probl&#232;me de m&#233;moire...



class TemporaryA;



class A

{    

    int a;

public:

    A();

    int get_value();

    void set_value(int new_a);

    TemporaryA& operator+(A& other);

    A& operator =(A& other);

    A& operator= (TemporaryA& other);

};



 class  TemporaryA : public A {};



A::A(){ a =0; }



int A::get_value(){ return a; }



void A::set_value(int new_a) { a= new_a; }



TemporaryA& A:: operator +(A& other) {

    TemporaryA* sum  = new TemporaryA;

    sum->set_value(this->get_value() + other.get_value());

    return *sum;

}



A& A::operator= (A& other) {

     this ->set_value(other.get_value());

    return *this;

}



A& A::operator =(TemporaryA& other) {

    this->set_value(other.get_value());

    delete &other;

    return *this;

}



C'est un peu plus beau que ce que j'ai fait plus haut, mais c'est toujours aussi foireux pour la m&#233;moire...



J'ai comme on dit "besoin d'un p'tit coup d'pouce" 



ps:

Je suis oblig&#233; de surd&#233;finir les constructeurs car mon vrai projet est avec des matrices dynamiques...

Ne me dites pas de changer de language pour faire ca, je sais bien que
le c++ n'est pas top pour les math, mais c'est pour un projet officiel
en c++, donc je n'ai pas ce choix...

C'est pas m&#233;ga urgent mais je dois quand m&#234;me le rendre en janvier, et j'ai pas mal de boulot &#224; c&#244;t&#233;...





MERCI BEAUCOUP !!! 




Duchon.

BunoCS · Accepted Answer

Hello,
l'op&#233;rateur "+" se surcharge comme suit:


A operator+(A& other1, A& other2);

Ce que tu as fait est pour l'op&#233;rateur "+="...

Buno
----------------------------------------
L'urgent est fait, l'impossible est en cours. Pour les miracles, pr&#233;voir un d&#233;lai...

le_duche · Answer

Dans le cas de mes matrices, en friend alors ?

J'essayerai ce soir...

merci !




Duchon.

BunoCS · Answer

Effectivement, j'ai oubli&#233; de pr&#233;ciser "friend" mais tu as corrig&#233; tout seul...

Buno
----------------------------------------
L'urgent est fait, l'impossible est en cours. Pour les miracles, pr&#233;voir un d&#233;lai...

cs_Aquarian · Answer

Salut,

On peut r&#233;gler le probl&#232;me diff&#233;remment, il suffit juste de rajouter les "const" qui manquent dans ton code sinon l'ent&#234;te pour l'op&#233;rateur + peut bien &#234;tre &#233;crit comme tu l'as fait. Il compile chez moi avec les const rajout&#233;s :

class A
{
    int a;
public:
    A() {
        a=0;
    }
    
    int get_value() const {
        return a;
    }
    
    void set_value(int new_a) {
        a=new_a;
    }


    A operator+(const A& other) const{
        A sum;
        sum.set_value(this->get_value() + other.get_value());
        return sum;
    }


    A& operator=(const A& other)
    {
        this->set_value(other.get_value());
        return *this;
    }
};

De cette fa&#231;on on &#233;vite les op&#233;rateur friend :)

A bient&#244;t

_________
Aquarian

luhtor · Answer

Non, normalement l'op&#233;rateur + ca doit etre un friend, et pas une fonction membre.

cs_Aquarian · Answer

Ca ne doit pas &#234;tre obligatoirement un friend... 
Les deux s'utilisent, je ne pense pas qu'une m&#233;thode soit meilleure par rapport &#224; l'autre mais peut-&#234;tre qu'il y a une raison telle qu'utiliser un friend dans ce cas serait pr&#233;f&#233;rable.

_________
Aquarian

le_duche · Answer

Vous battez pas  !

Je vais reagarder ca tranquillement ce soir (pas le net chez moi...) et je vous dirai demain si je m'en suis sorti 



Merci beaucoup en tous cas !

Duchon.

cs_Aquarian · Answer

Mais non, ma r&#233;ponse est peut-&#234;tre un peu s&#232;che mais ce n'&#233;tait pas voulu :(
En fait j'aimerai savoir comment l'un des deux choix peut-&#234;tre justifi&#233; suivant les cas.
_________
Aquarian

BunoCS · Answer

sans friend --> surcharge d'op&#233;rateurs internes &#224; la classe (+=,-=,...)
avec friend --> surcharge d'op&#233;rateurs externes (+, -, ...)

A priori, la d&#233;claration des op&#233;rateurs avec friend permettrait &#224; ces derniers de manipuler les donn&#233;es membres de leurs op&#233;randes...

Buno
----------------------------------------
L'urgent est fait, l'impossible est en cours. Pour les miracles, pr&#233;voir un d&#233;lai...

le_duche · Answer

et je peux laisser le += -= *= ... dans la classe et mettre les op&#233;rateur binaire en friend ?
Duchon.

BunoCS · Answer

C'est ce que je fais, &#233;tant donn&#233; qu'avec les op&#233;rateurs internes, tu agis directement sur l'objet courant

Buno
----------------------------------------
L'urgent est fait, l'impossible est en cours. Pour les miracles, pr&#233;voir un d&#233;lai...

cs_Aquarian · Answer

Merci pour vos r&#233;ponses 

A bient&#244;t.
_________
Aquarian

le_duche · Answer

Merci tout le monde !
Duchon.

Argh! Problème de constructeur de recopie et de surdéfinition de =

13 réponses

Votre réponse

Discussions similaires