Prob avec "!"

Question

Bonjour a tous!

Voila, mon prob est que g créer une classe qui permet de manipuler des ensembles d'entier. Et là, g une fonction membre qui vérifie si 2 ensembles sont égaux qui est codé comme ceci :


bool ens_entiers::operator ==(ens_entiers e)
{
    if (nb!=e.card()) return false;
    for(int i=0;i<nb;i++)
    {
        if ((e[tab[i]])==0) return false;
    }
    return true;
}


je precise que ma classe est la suivante :


class ens_entiers
{
    private :
    int *tab;
    int nb;
    public :
    ens_entiers(int [] = NULL, int = 0);
    void operator <(int);
    int card();
    bool operator [](int);
    bool operator ==(ens_entiers);
    bool operator !=(ens_entiers);
    //Rajout d'une fonction pour afficher
    void affiche();
    ~ens_entiers();
};

C lors de la définition de la fonction != qu'intervient mon prob.
Le code est le suivant :


bool ens_entiers::operator !=(ens_entiers e)
{
    return !((*this)==e);
}


Le prob est que c deux fonctions me renvoie la même valeur de vérité.
Et là, g bo chercher mais je trouve pas le prob %-6 

Merci de m'accorder votre aide

PunkDude424 · Answer

Je sais pas si cest une faute de frappe ou koi mais ta un espace entre operator et !=.....y faut pas....et de plus tu devrais p-e donner un meilleur nom a tes fonction.....c'est pas tres bine de mettre des signe tel que !, = ou autre dans le nom dune fonction

cs_djl · Answer

PunkDude424 ==> ben non, la syntaxe de ce qu'il a ecris est correcte"c'est pas tres bine de mettre des signe tel que !, ou autre dans le nom dune fonction "> il s'agit la de la surcharge des operateur en c++ 

saturne_1606 ==> ton erreur est assez bizar, j'ait fait un test avec une classe (sans pointeurs) et ca marche, 
au pir tu redefini l'operateur !sans te servir du

bonne chance

saturne_1606 · Answer

merci pour ta reponse djl mais g deja essayer cette possibilité.
En fait, aprés plusieurs test je me suis apercu que la fonction == que g defini change le premier element de l'ensemble mis en parametre. Par exemple, si l'ens entrer en para est {4,2,3,1}, aprés l'execution de la fonction, elle sera {2242504,2,3,1}. Cependant, d'aprés mes tests l'ensemble est toujours le mm juste avant le "return true" de la la fin de fonction. Et là, je dis que je comprends plus rien?§?!

Merci pour votre aide

cs_djl · Answer

ya pourtant un moyen de s'en assurer, 

dans ton exemple cette implementation avec passage par reference marchera

bool ens_entiers::operator ==(const  ens_entiers& e) const
{
if (nb!=e.card()) return false;
for(int i=0;i<nb;i++)
{
if ((e[tab[i]])==0) return false;
}
return true;
}

ca marchera car je vien de piger ton erreur, tu passe un ensemble par valeur et tu n'a pas de  constructeur par copie donc c'est celui qui est implicitement generer par ton compilo qui est appeler et qd ya un pointeur ca fait boum

quand tu fait une classe qui a un pointeur comme membre pense a redefinir le constructeur, le constructeur par copie, le destructeur, et l'operateur =

saturne_1606 · Answer

Merci bcp pour ton aide djl :) 
En fait g trouver la solution, qui est comme ce que tu as dit :

bool ens_entiers::operator ==(ens_entiers &e)
{
if (nb!=e.card()) return false;
for(int i=0;i<nb;i++)
{
if ((e[tab[i]])==0) return false;
}
return true;
}

mais je comprenais pas pourquoi il fallait mettre le &.
Grace à toi, maintenant je sais :big) 
Merci encore

cs_djl · Answer

autre solution aussi mais qui est surtout une necessite c'est de redefinir le constructeur par copie


ens_entiers(const ens_entiers& e)
{
nb=e.nb;
tab=new int[nb];
for(int i=0;i<nb;i++) tab[i]=e.tab[i];
}


et ton operateur pourra marcher ainsi


bool ens_entiers::operator ==(ens_entiers e) const
{
if (nb!=e.card()) return false;
for(int i=0;i<nb;i++)
{
if ((e[tab[i]])==0) return false;
}
return true;
}


tu fera attention que la methode est declarer const car l'operateur n'a pas besoin de modifier l'objet cible donc par defaut on le protege avec const

de meme lorsque tu passe un objet par reference, c'est sont adresse que tu passe donc si tu le modifie ca sera plus une copie qui est modifié mais l'objet lui meme, c'est pourquoi il est utile de le proteger par un const lorsque tu n'a pas besoin de le modifier


bool ens_entiers::operator ==(const ens_entiers &e) const
{
if (nb!=e.card()) return false;
for(int i=0;i<nb;i++)
{
if ((e[tab[i]])==0) return false;
}
return true;
}


a+

Prob avec "!"

6 réponses

Votre réponse