Positiv +

Der Positiv-Operator dient der expliziten Positiv-Kennzeichnung eines Elementes und wird in C auch mit unary plus bezeichnet. Er wird stets vor das zu kennzeichnende Element geschrieben, beispielsweise +value oder +999.

999
999
-999
-999

#include <stdio.h>

int main(){
  int pos = + 999;
  int neg = - 999;
  printf("%d\n",     pos);
  printf("%d\n",   + pos);
  printf("%d\n",     neg);
  printf("%d\n",   + neg);
  return 0;
}

Siehe auch Negativ-Operator -

Details

Der Positiv-Operator erwartet einen Operanden als rvalue und wird von rechts nach links abgearbeitet. Der Rückgabewert ist ein rvalue und hat denselben Typ wie der Operand.

Die semantische Bedeutung der Positiv-Kennzeichnung ist die Multiplikation mit +1. Zumindest für die arithmetischen Typen ist somit klar, dass der Positiv-Operator keinerlei Wirkung hat, er ist kein Absolut-Operator, da er aus dem negativen Wert nicht einen positiven macht, sondern ihn nur mit +1 multipliziert. Für den Absolut-Wert ist die Funktion abs() zuständig.

Folgende Konstrukte sind wenig sinnvoll, jedoch möglich:

999
-999
999

  printf("%d\n", + + pos);
  printf("%d\n", + + neg);
  printf("%d\n", + + + + + + + pos);

Vorsicht: Folgende Zeile sieht zwar fast gleich aus, allerdings handelt es sich aufgrund des fehlenden Abstandes zwischen den den beiden + hier um den Increment-Operator, welcher die Variable verändert:

1000

  printf("%d\n",  ++ pos);

Dieser Unterschied ist jedoch hinfällig, wenn der Positiv-Operator gemischt mit dem Negativ-Operator auftritt, da ein solcher Operator nicht existiert und somit als jeweils einzelne Positiv- und Negativ-Operatoren aufgelöst wird:

-999
-999
-999
-999

  printf("%d\n", - + pos);
  printf("%d\n",  -+ pos);
  printf("%d\n", + - pos);
  printf("%d\n",  +- pos);

Der Positiv-Operator hat somit für den Programmierer in erster Linie nur kosmetischen Nutzen, da er Formeln und Zuweisungen übersichtlicher schreiben kann:

  val1 = - 123;
  val2 = + 456;
  val3 = - 789;

Überladen des Operators

Den Positiv-Operator zu überladen macht nur selten Sinn, da bei normalen Anwendungen kaum Fälle auftreten, bei denen eine Multiplikation mit +1 irgend etwas bewirkt. Für Ausnahmen in speziellen mathematischen Theorien sei auf Expertenwissen verwiesen. Es ist trotzdem notwendig, den Operator zu definieren, denn die oben angesprochene Multiplikation mit +1 ist nur die semantische Bedeutung und wird nicht wirklich so übersetzt. Selbst kreierte Klassen müssten hierfür theoretisch ein 1-Element definieren, was jedoch in C++ so direkt nicht möglich ist, sondern nur über den Positiv-Operator. Wird somit der Positiv-Operator an einem Objekt aufgerufen, das keinem eingebauten Typ entspricht, erhält man den Fehler error: no match for 'operator+' in ...

Die Prototypen für das Überladen des Positiv-Operators sind die folgenden (Einschränkungen und Erläuterungen siehe Überladen von Operatoren):

inside class


outside class

Type operator +();
Type operator +() const;

Type operator +(Type);

Vorsicht ist geboten bei dem Prototypen ausserhalb der Klasse: Wenn er innerhalb der Klasse steht, wird er von den Compilern nicht als Fehler erkannt, da er dem Prototypen des Additions-Operators entspricht.

Ein mehr oder weniger sinnvolles Beispiel für das Überladen des Operators ist das folgende, wo eine Matrix bei Auftreten des Positiv-Operators auf eine positive Determinante getestet und bei Negativität eine Warnung ausgegeben wird:

Determinant: 1.000000

Determinant negative!
Determinant: -1.000000

#include <cstdio>

class Matrix22{
  float a[4];
public:
  Matrix22(float d){a[0]=d; a[1]=0; a[2]=0; a[3]=d;}
  float& operator [](unsigned int i){return a[i];}
  float determinant() const {return a[0]*a[3] - a[1]*a[2];}
  
  const Matrix22& operator +() const {
    if(determinant() < 0){
      fprintf(stderr, "Determinant negative!\n");
    }
    return *this;
  }
};

int main(){
  Matrix22 m(1);
  printf("Determinant: %f\n", (+m).determinant());
  m[0] = -1;
  printf("Determinant: %f\n", (+m).determinant());
  return 0;
}