Héritant et l'affectation virtuelle prioritaire == opérateur

voix
0

J'ai lu ce , mais cette discussion est seulement opérateur qui prend la comparaison base ou classe dérivée en tant que paramètre. Dans mon cas , je voudrais hériter opérateur virtuel pour le paramètre totalement différent (std :: string dans ce cas) et je ne pouvais pas trouver même une discussion sur ce sujet.

Donc, dans mon cas, j'ai le code suivant:

#include <string>
#include <iostream>

class Base {
public:
    Base(std::string s) : str(s) {}
    virtual bool operator==(const std::string& s) const { return s == str; };


protected:
    std::string str;
};

class Derived : public Base {
public:
    Derived(std::string s) : Base(s) {}
    //bool operator==(const std::string& s) const override { return s == str; };
    //bool operator==(const double& d) const { return d == doub; };
protected:
    double doub;
};


int main() {
    std::string foo = foo;
    Derived object(foo);

    if (object == foo)
        std::cout << equal << std::endl;
}

opérateur chaîne est correctement dérivée (code compilait) dans ce cas. Mais si je voudrais définir un autre opérateur, pour le type double (décommentant deuxième commentaire), le code ne compile, comme compilateur ne voit pas pour l'opérateur chaîne définie dans la classe de base. Décommentant premier commentaire, l'opérateur de la base-à-dire explicitement prioritaire fonctionne à nouveau.

Quelqu'un peut-il expliquer un tel comportement?

Créé 27/11/2018 à 15:08
source utilisateur
Dans d'autres langues...                            


1 réponses

voix
3

Disons que vous avez

class Derived : public Base {
public:
    Derived(std::string s) : Base(s) {}
    bool operator==(const double& d) const { return d == doub; };
protected:
    double doub;
};

Le problème ici est que votre Derived::operator==fonction cache la Base::operator==fonction.

Ceci peut être résolu en tirant le operator==symbole de la Baseclasse dans la Derivedclasse, avec le usingmot - clé:

class Derived : public Base {
public:
    Derived(std::string s) : Base(s) {}
    using Base::operator==;   // Get the symbol from the Base class into the scope of the Derived class
    bool operator==(const double& d) const { return d == doub; };
protected:
    double doub;
};
Créé 27/11/2018 à 15:15
source utilisateur

Cookies help us deliver our services. By using our services, you agree to our use of cookies. Learn more