Qu'est-ce que l'opérateur plus unaire faire?

StackOverflow https://stackoverflow.com/questions/727516

  •  05-09-2019
  •  | 
  •  

Autres conseils

En fait, plus unaire Finalité faire quelque chose - même en C. Il effectue les

De seconde édition K & R:

  

Le unaire + est nouvelle à la norme ANSI. Il a été ajouté pour la symétrie avec le unaire -.

Je l'ai vu utilisé pour plus de clarté, de mettre l'accent sur la valeur positive à la différence d'une valeur négative: 

shift(+1);
shift(-1);

Mais c'est une utilisation assez faible. La réponse est sans aucun doute sature.

Une chose unaire + intégré ne se tourne lvalue dans un rvalue. Par exemple, vous pouvez le faire 

int x;
&x;

mais vous ne pouvez pas le faire 

&+x;

:)

P.S. « Surcharger » est certainement pas la bonne réponse. Unaire + a été hérité de C et il n'y a pas d'opérateur au niveau utilisateur surcharge en C.

La principale chose unaire + est la promotion de accomplit le type à un int pour les types de données plus modeste que int. Cela peut être très utile si vous essayez d'imprimer des données à l'aide de l'omble std::cout sous forme de données numériques. 

char x = 5;
std::cout << +x << "\n";

est très différent de 

char x=5;
std::cout << x << "\n";

Il est également disponible pour la surcharge, mais dans la pratique de votre surcharge devrait être près d'un NOP.

Si vous avez besoin d'imprimer la valeur numérique des octets bruts (par exemple, les petits numéros enregistrés en tant que char) pour le débogage ou une raison quelconque, unaire + peut simplifier le code d'impression. Considérez 

char c = 42;
cout << c << endl;           // prints "*\n", not what you want in this case
cout << (int)c << endl;      // prints "42\n", ok
cout << +c << endl;          // prints "42\n", much easier to type

Ceci est juste un exemple rapide. Je suis sûr qu'il ya d'autres moments où unaire + peut aider à traiter vos octets de plus comme des numéros au lieu de texte comme.

Une friandise historique. Le comité de normalisation C99 a également pensé les utilisations existantes de unaire étaient assez rares, comme le prouve qu'ils envisagent de le réutiliser pour obtenir une autre caractéristique de la langue: l'inhibition de l'évaluation en temps de traduction des expressions constantes à virgule flottante. Voir la citation suivante de la C Justification, section F.7.4:

  

Une première version de cette spécification autorisée traduction en temps arithmétique constante, mais   habilité de l'opérateur unaire +, lorsqu'elle est appliquée à un opérande, pour inhiber temps de traduction   évaluation des expressions constantes.

En fin de compte, la sémantique ont été inversés, avec une évaluation d'exécution forcée dans la plupart des contextes (au moins jusqu'à la « comme si » la règle), et la capacité d'appliquer l'évaluation en temps de traduction par l'utilisation des initialisations statiques. Notez que la principale différence réside dans l'apparition d'exceptions flottantes ponctuelles, et d'autres arrondi en virgule flottante ou les paramètres de précision, il est présent.

Pas grand-chose. L'argument général pour permettre à la surcharge de operator+() est qu'il ya monde certainement réel utilise pour la surcharge operator-(), et il serait très bizarre (ou asymétrique) si vous deviez permettre une surcharge operator-() mais pas operator+().

Je crois que je l'ai lu cet argument de Stroustrop, mais je n'ai pas mes livres avec moi pour le vérifier. Je peux me tromper.

Plus unaire était présent dans C, où il n'a absolument rien fait (un peu comme le mot-clé auto). Afin de ne pas avoir, Stroustrup aurait dû introduire une incompatibilité gratuite avec C.

Une fois qu'il était en C ++, il était naturel pour permettre une fonction de surcharge, comme le moins unaire, et Stroustrup aurait pu introduire pour cette raison si elle était pas déjà.

Alors, cela ne signifie rien. Il peut être utilisé comme comme une sorte de décoration pour rendre les choses plus symétrique, en utilisant comme +1,5 opposé à -1,5 par exemple. En C ++, il peut être surchargé, mais ça va être source de confusion si operator+() ne fait rien. Rappelez-vous la règle standard. En cas de surcharge des opérateurs arithmétiques, faire des choses comme les ints font

Si vous cherchez une raison pour laquelle il est là, trouver quelque chose sur l'histoire ancienne de C. Je pense qu'il n'y avait pas une bonne raison, que C n'a pas été vraiment conçu. Considérez le mot-clé auto inutile (probablement contrairement à static, maintenant recyclé en C ++ 0x), et le mot-clé entry, qui n'a jamais rien fait (et plus tard omis dans C90). Il y a un célèbre courriel dans lequel Ritchie ou Kernighan disent que, quand ils ont pris conscience de la priorité des opérateurs a eu des problèmes, il y avait déjà trois installations avec des milliers de lignes de code qu'ils ne voulaient pas rompre.

Je ne peux pas citer une source pour cela, mais je suis venu à comprendre qu'il est pour la promotion de type explicite, ce qui implique la conversion de type sans perte. Qu'il met au sommet de la hiérarchie de conversion,

  • Promotion: new_type operator+(old_type)
  • Conversion: new_type(old_type)
  • Avec: operator(new_type)(old_type)
  • Coercion: new_type operator=(old_type)

Bien sûr, cela est de mon interprétation d'une note dans l'un des Microsoft (vraiment vieux) c / c ++ manuels que j'ai lu il y a environ 15 ans, donc prendre avec un grain de sel. 

#include <stdio.h>
int main()
{
    unsigned short x = 5;
    printf ("%d\n",sizeof(+x)); 
    printf ("%d\n",sizeof(x)); 
    return 0;
}

Comme le montre l'exemple ci-dessus, le unaire + change vraiment le type, la taille 4 et 2 respectivement. Bizarre que l'expression + x est en effet calculé dans le sizeof, je pensais que ce n'était pas censé. Peut-être que cela est dû au fait que sizeof a la même priorité que le unaire +.

Je suppose que vous pouvez l'utiliser pour faire toujours un nombre positif. Il suffit de surcharger l'opérateur unaire + pour être abs. Pas vraiment la peine de confondre vos collègues développeurs, sauf si vous voulez vraiment juste pour obscurcir votre code. Ensuite, il travaillerait bien.

EDIT Réécriture complètement, parce que j'étais waaaayyy hors dans ma première réponse.

Cela devrait vous permettre de gérer la déclaration explicite de votre type comme une valeur positive (je pense que la plupart du temps dans les opérations non-mathématiques). Il semble que la négation serait plus utile, mais je pense que est ici un exemple où il pourrait faire une différence: 

public struct Acceleration
{
    private readonly decimal rate;
    private readonly Vector vector;

    public Acceleration(decimal rate, Vector vector)
    {
        this.vector = vector;
        this.rate = rate;
    }

    public static Acceleration operator +(Acceleration other)
    {
        if (other.Vector.Z >= 0)
        {
            return other;
        }
        return new Acceleration(other.Rate, new Vector(other.vector.X, other.Vector.Y, -other.vector.Z));
    }

    public static Acceleration operator -(Acceleration other)
    {
        if (other.Vector.Z <= 0)
        {
            return other;
        }
        return new Acceleration(other.Rate, new Vector(other.vector.X, other.Vector.Y, -other.vector.Z));
    }

    public decimal Rate
    {
        get { return rate; }
    }

    public Vector Vector
    {
        get { return vector; }
    }
}
Non affilié à StackOverflow
scroll top