c++ polymorphisme de la surcharge d'opérateur

Comment puis-je faire fonction virtuelle pure d'un opérateur+(); fonction.
wheh ı faire comme ceci dans la classe de base
int operator+()=0;
compilateur donne une erreur .
dans dériver de la classe de l'opérateur+() la fonction
compilateur dire qui dérivent de la classe ne peut pas faire . à la suite de la classe est abstraite
Je sais que je ne peut pas créer un objet de classes abstraites, mais maintenant, j'essaie de faire dériver de la classe de l'objet.

Voici le code

#include <iostream>
using namespace std;
class ana {
    protected :
    int x;

    public :
    virtual int operator+()=0;
    virtual void operator=(ana&)=0;
    };

class baba : public ana{
    public:
    baba(int k){x=k;}
    int   operator+(baba &ali){
        int k;
        k=x+ali.x;
        return k;
    }
   void operator=(baba &ali){
       x=ali.x;
       }


    };

int main(){
    baba k(4);

    return 0;
    }
Merci de nous montrer le code.
Il est peu probable que vous avez trouvé un bon de conception impliquant des opérateurs mis en œuvre en tant que membre virtuel fonctions. Je n'ai jamais vu de telles bêtes. Que voulez-vous accomplir cela?
En plus de @sbi, les opérateurs sont à peu près seulement pour les jolies syntaxe. Si vous êtes à l'aide de virtual toutes les fonctions de votre action doit passer par des pointeurs de toute façon, de sorte que votre code sera probablement plus laid avec les opérateurs. Je soupçonne, en effet, que vous aurez à appeler explicitement operator+ comme (&myobj)->operator+(x)
Pour celui qui upvoted ce - dans quel sens est-ce une bonne question?
Butterworth: Après Troubadour posté le "code" de la "réponse" ci-dessous, je upvoted de -1 à 0. Pas sûr que ça mérite d'aller plus haut, mais je ne pense pas qu'avec cette partie résolues, il aurait mérité un score négatif. - Je m'attendre si quelqu'un n'est pas d'accord, ils voteront redescendre.

OriginalL'auteur hasan | 2010-06-03

  1. 10

    Votre vague de mentions de code sont pratiquement impossibles à suivre. Pour répondre à votre question "Comment puis-je faire fonction virtuelle pure d'un opérateur+(); function", il n'y a absolument pas de secret pour elle, par exemple, considérer les points suivants trivial programme:

    #include <iostream>

class base {
public:
  virtual int operator+(int) const = 0;
};

class deriv: public base {
public:
  int operator+(int) const {return 23;}
};

int main() {
  deriv d;
  base& b = d;
  std::cout << b + 15 << std::endl;
  return 0;
}

    Cette compile et fonctionne correctement et émet 23 comme prévu. Tout ce que vous faites mal, évidemment, il doit donc être différents de ce (et probablement pas connecté à la question d'avoir un opérateur de surcharge être virtuelle pure).

    Modifier: (selon les commentaires, ajoutés const à la méthode de la juste au cas où vous voulez l'appeler w/const base& -- notez que d'autres réponses ont également omis cette const; et, aussi par les commentaires):

    Si vous voulez être en mesure de faire 15 + b, il suffit d'ajouter un libre-debout fonction pour cette raison, dire juste avant main:

    inline int operator+(int i, const base&b) {
    return b + i;
}
    Cela a le désavantage évident que 15 + b ne fonctionnera pas.
    Ce qui est encore pire (rien ne vous arrête de surcharge operator+(int,base) appeler operator+(base,int)), cela ne fonctionne pas quand b est un const b&. Même si je suis sûr qu'Alex ne sait pas quoi faire à ce sujet, il est néanmoins mal manquant dans une réponse à ce qui est évidemment un C++ novice.
    OK, permettez-moi de modifier la question pour la rendre plus novice friently (j'ai remarqué le même manque de "évident const" dans tous les autres réponses, d'ailleurs).
    Bon. Jusqu'-voté.

    OriginalL'auteur Alex Martelli

  2. 4

    Si vous êtes à la recherche d'un opérateur standard+() de la mise en œuvre, puis, malheureusement, c'est impossible:

    class X { 
public:
     virtual X operator+(X const &rhs) = 0;
};

    Ce code ne peut pas compiler, car le compilateur ne peut pas retourner un abstrait X classe par valeur.

    Pourrait return X* ou un smartpointer à X. l'Enfer, il pouvait écrire son propre pointeur intelligent de la classe qui est vraiment juste un std::shared_ptr et de résoudre cela de cette façon.
    Comme Alex l'a noté, cela, aussi, manque un indispensable const.

    OriginalL'auteur Kornel Kisielewicz

  3. 3

    Note : Question ont été mis à jour, en faisant cette réponse moins valides.

    Si vous êtes à la description est correcte, vous êtes juste oublier d'utiliser la virtual mot-clé pour spécifier l'opérateur virtuel...

    class Addable{
public:
    virtual int operator+ const ( const Addable& other ) = 0; //pure virtual
    virtual int operator+ const ( int number ) = 0; //pure virtual
};
    re: mon commentaire sur le post original, comment pourrait-on appel une telle bête, un pointeur Addable * px? Mon c++ est un peu louche.
    Pas de problème. Pour les types définis par l'utilisateur, a+b devient soit operator+(a,b) ou a.operator+(b), selon la façon dont l'opérateur est surchargé. Ce dernier est, sauf pour le drôle de nom de la fonction qui permet à l'infixe syntaxe, ne diffèrent pas de a.f(b).
    Je persiste à croire que des modèles impliquant des opérateurs virtuels sont absurdes.
    Cela dépend de ce que vous essayez d'accomplir. Par exemple, si vous étiez à la mise en œuvre d'une dynamique de type langage de script comme Lua, on pourrait dire que polymorphes opérateurs, c'est que la rue.
    Jamais l'esprit, j'ai raté une réponse par @Jerry Cercueil ailleurs. Je ne savais pas virtuel de la fonction de recherche qui s'est passé au travers de références ainsi que par le biais de pointeurs.

    OriginalL'auteur Klaim

  4. 1

    Je vois deux questions que vous devez vous adresser, ou à tout le moins de mieux la comprendre. Ils se résument au fait que vous n'avez pas résolu le virtuelle pure dans la déclaration de votre classe de base, ana:

    1) operator+(): Votre classe baba définit un autre opérateur + de la classe de base. En particulier, ana::operator+() est unaire + opérateur (n'accepte qu'un seul opérande), tandis que baba::operator+(baba& ali) est un opérateur binaire (accepte les deux opérandes) sur baba. Vous avez besoin de décider de les utiliser et de les utiliser. Si vous souhaitez utiliser le binaire + (qui, compte tenu de votre définition dans baba est ce que je pense que vous voulez) puis vous déclarer en ana:

    virtual int operator+(const ana&) const =0;

    et dans baba:

    virtual int operator+(const ana& ali) const {return x+ali.x; }

    Pourquoi ce doit être une méthode virtuelle pure dans ana, depuis x est défini dans ana est curieux. Il va faire des choses intéressantes si vous avez d'autres classes dérivées que de faire les choses différemment (perte de commutivity est susceptible d'entraîner). Mais je pense que vous avez vos raisons, je ne vais pas plus loin.

    2) l'opérateur=(ana&): Vous avez également un problème avec l'opérateur d'affectation des déclarations. Encore une fois, vous n'êtes pas la résolution de l'virtuelle pure. Dans ana vous avez:
    virtual void operator=(ana&)=0; tandis que dans baba vous avez: void operator=(baba &ali). Les arguments sont différents depuis baba& n'est pas le même que ana&; ainsi, le pur virtuel déclaration n'est pas résolu. Afin de résoudre ce problème, vous voudrez probablement changer la déclaration en ana:

    virtual void operator=(const ana&)=0

    et dans baba:

    virtual void operator=(const ana& ali) { x=ali.x; }

    J'ai des préoccupations semblables à pourquoi vous voulez déclarer cela comme un pur virtuel puisque, encore une fois, il suppose que les différentes classes dérivées de le mettre en œuvre différemment conduisant à comportement intéressant. Encore une fois, je suis sûr que vous avez vos raisons.

    J'espère que cela aide.

    Comme Alex l'a noté, cela, aussi, manque un indispensable const.
    Il doit être fixé maintenant.

    OriginalL'auteur andand

  5. 0

    La syntaxe d'une fonction virtuelle pure serait quelque chose comme:

    class X { 
public:
     virtual int operator+(X const &rhs) = 0;
};

    Noter, cependant, que vous ne veulent rarement à le faire -- vous souhaitez généralement une surcharge de operator+ être mis en œuvre comme une fonction libre, pour permettre la conversion de l'opérande de gauche (si nécessaire).

    Ceci est incorrect, vous ne pouvez pas retourner une classe abstraite.
    Heureusement hasan veut revenir juste un int.
    ne serait probablement pas -- mais, contrairement à votre commentaire précédent, un pointeur n'est pas nécessaire; le polymorphisme via des références est parfaitement bien. Néanmoins, le tout est problématique.
    merci, je n'étais pas au courant de cela. Je pensais que je savais, c++...
    Comme Alex l'a noté, cela, aussi, manque un indispensable const.

    OriginalL'auteur Jerry Coffin

  6. 0

     #include 
using namespace std; 
class ana { 
protected : 
int x; 
public :
     


    virtual int operator+()=0; 
virtual void operator=(ana&)=0; 
};
     


    class baba:public ana{ 
public: 
baba(int k){x=k;} 
int operator+(baba &ali){ 
int k; 
k=x+ali.x; 
return k; 
} 
void operator=(baba &ali){ 
x=ali.x; 
}
     


    };

    int main(){
    baba k    (4);

    return 0;
    }<code>what is wrong here?

    Avez-vous tout simplement ignorer tous les commentaires ci-dessus? "int operator+(baba &ali);" n'est PAS primordial "virtual int operator+()=0;" - qu'ils ont des arguments différents.
    Je pense qu'il est ajouté une réponse par erreur au lieu de modifier la question. C'est le code que nous avons demandée.
    J'ai ajouté le code à votre question. Vous pouvez supprimer cette réponse.
    Merci beaucoup @Colin

    OriginalL'auteur hasan