Ne Surcharge de l'Opérateur<< travaux à l'intérieur de la classe?

Je veux dire, j'ai essayé de la surcharge de l'opérateur<< à l'intérieur de la classe

comme ce

 class A {
      public:
           ostream &operator<<(ostream &os);//which doesnt work

      private:
           friend ostream &operator<<(ostream &os, const A& a); //Works
           int i;

 };

  Definition
          ostream &operator<<(ostream &os, const A& a) {
              os<<a.i;
              return os;
          }

pourquoi ne puis-je pas la surcharge de l'opérateur à l'intérieur de la classe spécifique à la classe? ou ai-je raté quelque chose? ou Suis-je stupide de penser dans une telle façon? Veuillez informer.

double possible de la surcharge des opérateurs (voir en particulier cette réponse)

OriginalL'auteur howtechstuffworks | 2012-02-19

  1. 17

    La fonction de membre:

    ostream &operator<<(ostream &os);

    ne travail, mais pas pour la situation que vous souhaitez. Il sera appelé lorsque vous faites quelque chose comme:

    A a;
a << std::cout;

    c'est à dire l'endroit où l'objet est à la gauche de l'opérateur.

    OriginalL'auteur Oliver Charlesworth

  2. 18

    Le problème, c'est que votre operator<< prendrait ostream comme deuxième paramètre, pas une première. De cette façon, vous pourriez faire myObject << std::cout, mais elle ne serait pas intuitive et vous ne serait pas capable de la chaîne d'appels en raison de operator<< être de gauche associative.

    Un autre avantage de la déclaration de l'opérateur comme un ami plutôt que comme une fonction membre, c'est que les conversions automatiques peuvent se produire. Cela signifie que si vous avez une classe B qui ne découle pas d'A, mais ne disposent d'un B(A const&) constructeur, vous serez toujours en mesure de faire std::cout << my_b; et l'ont converti en A et puis imprimé.

    Heureusement, la définition de operator<< comme un ami peut être fait à l'intérieur de la classe, si vous préférez. Votre code peut être écrit comme

    class A {
    int i;
    friend std::ostream& operator<<(std::ostream& o, A const& a) {
        o << a.i;
        return o;
    }
};

    Pourquoi ne pas le standard vous permettent de spécifier de quel côté l'argument devrait aller? On dirait qu'il a fait, et ajouter le left_of et right_of des mots clés pour préciser:

    struct B;

struct A {
     A left_of operator+(B const&) {
         return *this;
     }
};

struct B {
     B right_of operator+(A const&) {
         return *this;
     }
};

    Ce qui se passe maintenant, quand nous ne A a; B b; f(a + b);? Chaque classe a un opérateur qui s'occupe de cette affaire, ce qui signifie que nous ne pouvons pas décider. Voyant que de nombreux opérateurs devraient être des amis en raison de la conversion des possibilités de toute façon, ne permettant pas ce genre de chose n'est pas un gros problème, et empêche ce genre d'ambiguïtés. (Bien sûr, vous pouvez également définir un membre de l'opérateur et un gratuit, qui serait la cause d'un problème très similaire.)

    Par la manière, que les choses sont, la définition de votre friend operator<< ne renvoie rien, ce qui gâchera le chaînage.

    ^ j'ai u..... Mais le premier n'a pas de sens du tout..... il a été fait, parce que, pour maintenir la cohérence entre tous les opérateurs, où toutes les choses apparaissent à la droite de l'opérateur, est considéré comme un paramètre?
    Anonyme downvoter, n'hésitez pas à commenter.
    ^ LOL, je suppose que quelqu'un est gâcher.......
    ^ merci anton...... J'ai compris beaucoup mieux maintenant..... Btw, je suis d'accord ur argument pour l'opérateur + ... je suis pas en train de dire, que nous devrions avoir à spécifier la façon dont il doit être fait... je suis d'accord que tous les opérateurs par défaut de prendre la bonne valeur, mais ce qui se passe si nous décidons de le faire dans l'autre sens? par défaut par la gauche, pour les opérateurs dans le besoin? comme <<.... << opérateur prend toujours la gauche comme argument et se lier à la classe spécifiée dans le droit..... Ou était-il négligé, à cause des deux inconvenients, yout mentionnés au début de commentaire...????
    Lors de l'utilisation operator<< pour la sortie est commun, il n'est pas le seul à l'utiliser, et de faire certains opérateurs prennent la valeur à droite et les autres la valeur de gauche serait encore plus de maux de tête.

    OriginalL'auteur Anton Golov

  3. 1

    Rappelez-vous que pour un non fonction membre statique d'une classe au premier argument de ce pointeur.
    Donc, la signature de votre "opérateur<<", d'après la compilation deviendra:

    ostream &operator<<(A *this, ostream &os);

    Cela fonctionne quand vous faites quelque chose comme:

    A obj;
obj << std::cout;

    Penser à "obj" comme premier argument et "std::cout" de la 2ème argument de l'opérateur "<<".

    Meilleure façon de surcharge "<<" est en utilisant un ami, car de cette façon, vous pouvez faire votre opérateur surchargé associatif.

    OriginalL'auteur Ankit Agrawal