Pourquoi l'opérateur ne surcharge-t-il pas les pointeurs autorisés à travailler?

Que par le commentaire sous cette réponseles références ont été introduites principalement à l'appui de la surcharge d'opérateur qui cite Bjarne Stroustrup:

Références ont été introduites principalement
à l'appui de la surcharge d'opérateur. C
passe chaque argument de fonction par
valeur, et où le passage d'un objet par
la valeur serait inefficace ou
inappropriés, l'utilisateur peut passer d'un
pointeur. Cette stratégie ne fonctionne pas
d'où la surcharge d'opérateur est utilisé. Dans
ce cas, la notation, la commodité est
un élément essentiel pour qu'un utilisateur ne peut pas être
prévu pour insérer une adresse de
les opérateurs si les objets sont de grande taille.

Ce qui implique que la surcharge d'opérateur ne peut pas travailler avec le pointeur. Mais il n'a pas d'expliquer clairement pourquoi la surcharge d'opérateur avec les pointeurs ne peuvent pas travailler. Pourquoi ne pas la surcharge d'opérateur de travail pour les pointeurs?

De l'OMI, où les références sont utilisées, les pointeurs, peut également être utilisé à sa place.

source d'informationauteur cpuer

  1. 7

    Parce que si c'était possible, ce ne serait pas l'air bien, et ne serait pas aussi intuitif que sa référence.

    Suppose que c'est autorisé, alors on peut écrire:

    struct A{};
A a, *pa, b;

a = pa ;//doesn't look good, also not intuitive. (not real C++)

    Il ne semble pas bon, parce que, sur le côté gauche, vous avez la non-pointeur, sur le côté droit vous avez pointeur. L'air très très bizarre. Aussi, depuis les types ne correspondent pas, il n'a pas l'air très intuitive de ce qu'est exactement faire. Je veux dire, vous êtes affectation de pointeur vers un non-pointeur; qu'une telle cession est censé faire? Copie le contenu de l'adresse pointée par le pointeur vers la destination (non-pointeur) n'est pas très inttuitive.

    D'autre part, que son permis avec numéro de référence (de la réalité, pas une supposition):

    a = b; //looks good, intuitive, as now both side is same type

    En référence, vous avez tous les deux latéraux de même type, c'est seulement quand b est transmis à operator=() comme argument, il est passé à par référence (ou dire par pointeurcomme les références sont à sucre syntaxique de pointeurs.) pour éviter la copie, qui à son tour ne pas nuire à la performance, comme il le ferait si il est passé en valeur.

    Il serait également intéressant de noter que non seulement b est passé par référence (ou pointeur - dessous), a obtient également transmis à la fonction par pointeurcar nous savons que dans la fonction, le mot-clé this est en fait un pointeur.

    Donc références ont été introduites en C++, pour faire toute chose bonne apparence et intuitif pour les programmeurs, autrement ils sont pointeurs dessous. En fait, la plupart des compilateurs de mettre en œuvre les références à l'aide de pointeurs (pointeur-mécanisme) en interne.

  2. 5

    Pourquoi ne pas travailler pour les pointeurs? Parce que c'est ambigu. Serait

    ostream* operator<<(ostream* s, const char* c);

    match

    cout << 'a';

    ou

    cout << "a";

    ?

    Aussi, vous ne pouvez pas utiliser l'adresse de (&) avec une temporaire. Ce qui devrait ce faire:

    complex<double> a, b, c;
cout << a + b * c;

    depuis b * c est que temporaire, et la somme est aussi.

    ?

  3. 1

    Avec l'opérateur plus surchargé pour une lourde de classe, vous devez écrire le a + b (par valeur, inefficace) ou &a + &b (moche et compliqué) pour ajouter deux objets de cette classe. Mais avec les références que vous obtenez par-réf même lors de l'écriture a + b.

  4. 1

    Parce que la plupart des opérateurs ont déjà un autre sens établi lorsqu'il est appliqué à des pointeurs.

  5. 1

    La surcharge d'opérateur de travailler sur objets mais le pointeur n'est pas un objet en soi. Il pointe vers un objet.

  6. 1

    Compte de l'état

    c= a+b

    où l'opérateur + a été surchargé.
    Cette déclaration peut être interprétée par le compilateur comme

    c=operator+ (a, b)

    Depuis, ici les adresses de variables ne sont pas passé, donc nous ne pouvons les recueillir dans des variables de pointeur.

    Si nous voulons recueillir dans la variable pointeur , puis nous nous modifiez l'instruction comme suit:

    c=&a+&b;

    Mais cela signifie que nous essayons d'ajouter des adresses de a et de b, et non leurs valeurs. À de tels moments, seules les références peuvent être utilisés pour économiser de la mémoire.

  7. 0

    Les opérateurs peuvent pas être surchargé, lorsque les deux types impliqués sont des types intégrés (comme intfloat ou n'importe quel type de pointeur). La surcharge de l'opérateur pour une classe et un type primitif (ou vous pouvez simplement utiliser la conversion de type). Par exemple, vous pouvez ajouter std::string et const char *.

  8. 0

    Ce qui implique que l'opérateur
    la surcharge ne peut pas travailler avec le pointeur.

    Cela ne signifie pas que tout. Il états que la fourniture de références est un élément essentiel de notation de la commodité de sorte que le programmeur n'a pas à utiliser librement l'adresse de l'exploitant.

    Il est aussi le cas que la surcharge d'opérateur ne fonctionne pas avec les pointeurs, mais c'est essentiellement parce qu'il n'y a pas de syntaxe. Pourquoi? Demandez Stroustrup.

    Votre OMI est correct à condition d'un opérateur de déréférencement est utilisé avant le pointeur.