Hat der unäre + Operator einen praktischen Nutzen?

War der unäre + Operator nur zur Symmetrie mit dem Unären enthalten - -Operator, oder findet er praktische Verwendung im C++-Code?

Als ich hier suchte, stieß ich auf Was ist der Zweck des unären ‘+’-Operators in C?, aber die einzigen nützlichen Szenarien dort beinhalten Präprozessor-Makros. Das ist gut zu wissen, aber sie scheinen einige weniger häufige Situationen zu sein und beinhalten Makros. Gibt es Anwendungsfälle mit häufigerem C++-Code?

char ch="a";
std::cout << ch << '\n';
std::cout << +ch << '\n';

Die erste Einfügung schreibt das Zeichen a zu cout. Die zweite Einfügung schreibt den numerischen Wert von ch zu cout. Aber das ist ein bisschen obskur; Es verlässt sich darauf, dass der Compiler integrale Beförderungen für die anwendet + Operator.

Symmetrie mit unär - ist nicht völlig nutzlos; es kann zur Hervorhebung verwendet werden:

const int foo = -1;
const int bar = +1;

Und ein überladen einstellig + kann verwendet werden, um eine Operation zu bezeichnen, die dasselbe ergibt logisch value als Operand, während einige nicht triviale Berechnungen durchgeführt werden. (Ich habe gesehen, dass dies für Typkonvertierungen in Ada durchgeführt wurde, was unäre erlaubt +, aber keine Konvertierungen, um überladen zu werden.) Ich habe kein gutes C++-Beispiel zur Hand, und man könnte argumentieren, dass es schlechter Stil wäre. (Andererseits habe ich viele Gerüchte über Überlastung gesehen <<.)

Wie für warum C++ hat es, es dient wahrscheinlich hauptsächlich der Konsistenz mit C, das es mit dem ANSI-Standard von 1989 hinzugefügt hat. Die C Begründung sagt nur:

Unäres Plus wurde vom C89-Komitee aus mehreren Implementierungen übernommen, um die Symmetrie mit unärem Minus zu gewährleisten.

Wenn Sie sich ausdrücklich von einer Zahlenwertsemantik für eine Klasse fernhalten, irgendein Das Überladen von Operatoren ist klar, nicht “das zu tun, was die ints tun”. In diesem Fall kann das unäre Plus jede Bedeutung bekommen und viel mehr tun, als nur zurückzukehren *this

Prominentes Beispiel: Das einfache Plus von Boost.Spirit für die eingebetteten EBNFs Kleene Plus generiert eine Parser-Regel, die ihr Argument (ebenfalls eine Parser-Regel) einmal oder mehrmals übereinstimmen lässt.

Das Unäre + Operator verwandelt einen lvalue in einen rvalue:

struct A {
  static const int value = 1;
};

// ...

int x = std::min(0, A::value);

Oh nein! Dieser Code wird nicht verlinkt, weil jemand vergessen hat, ihn zu definieren (sowie zu deklarieren) A::value. std::min nimmt seine Argumente als Referenz so A::value muss eine Adresse haben, damit eine Referenz daran gebunden werden kann (technisch gesehen besagt die Eine-Definitions-Regel, dass sie genau einmal im Programm definiert werden muss).

Macht nichts, unäres Plus zur Rettung:

int x = std::min(0, +A::value);

Das unäre Plus erstellt ein temporäres mit demselben Wert, und die Referenz bindet an das temporäre, sodass wir die fehlende Definition umgehen können.

Das brauchen Sie nicht oft, aber es ist eine praktische Anwendung des unären Plus-Operators.

Unary + wendet integrale Beförderungen an. Die Antwort von @PeteBecker zeigt einen Weg, der nützlich sein kann.

Beachten Sie außerdem, dass ein Aufzählungstyp ohne Bereichseinschränkung zu einem ganzzahligen Typ hochgestuft wird, der alle Werte in darstellen kann enum. Also in C++03, auch ohne C++11’s std::underlying_type<T>du könntest es tun:

enum MyBitMask {
    Flag1 = 0x1,
    Flag2 = 0x2,
    Flag3 = 0x4,
    Flag4 = 0x8000000
};

inline MyBitMask operator&(MyBitMask x, MyBitMask y) {
    return static_cast<MyBitMask>( +x & +y );
}

inline MyBitMask operator|(MyBitMask x, MyBitMask y) {
    return static_cast<MyBitMask>( +x | +y );
}

Ein bisschen spät, aber hier ist eine sehr verdrehte Verwendung, über die ich gestolpert bin. Anscheinend die + -Operator kann nützlich sein (wenn auch vielleicht nicht unbedingt erforderlich), wenn Sie Sicherheitsvorkehrungen für die Möglichkeit entwerfen, auf leere Präprozessor-Token zu stoßen. In diesem Beitrag finden Sie eine ausführlichere Diskussion.

Das ist praktisch, aber keineswegs angenehm.

Unter anderem, + wandelt Lambdas in Funktionszeiger um. Normalerweise erfolgt die Konvertierung automatisch, manchmal jedoch nicht.

Dies kompiliert beispielsweise nicht:

std::array arr{
    [](int x){return x*x;},
    [](int x){return x*x*x;},
};

Sie könnten es zum Laufen bringen, indem Sie den Funktionszeigertyp als angeben std::array Vorlagenparameter, oder du könntest einfach das machen:

std::array arr{
    +[](int x){return x*x;},
    +[](int x){return x*x*x;},
};