Negativ -

Der Negativ-Operator dient der expliziten Negierung eines Elementes und wird in C auch mit unary minus bezeichnet. Er wird stets VOR das zu kennzeichnende Element geschrieben, beispielsweise -value oder -1000.

1000
-1000
-1000
1000

#include <stdio.h>

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

Siehe auch Positiv-Operator +

Details

Der Negativ-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 Negierung ist die Multiplikation mit -1. Dies entspricht dem Zweierkomplement bei Integer-Typen wie signed int, signed short und signed char.

Folgende Konstrukte sind nur begrenzt sinnvoll, jedoch möglich:

1000
-1000
-1000

  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 Decrement-Operator, welcher die Variable verändert:

999

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

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

-1000
-1000
-1000
-1000

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

Überladen des Operators

Für eigene Klassen ist es notwendig, den Negativ-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 Negativ-Operator. Wird somit der Negativ-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 Negativ-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 Subtraktions-Operators entspricht.

Hier ein Beispiel, in dem eine Matrix mit dem Negativ-Operator direkt negiert werden kann:

1.000000, 0.000000
0.000000, 1.000000

-1.000000, -0.000000
-0.000000, -1.000000

1.000000, 0.000000
0.000000, 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;}
  Matrix22(float a0, float a1, float a2, float a3){
    a[0]=a0; a[1]=a1; a[2]=a2; a[3]=a3;
  }
  void print(){
    printf("%f, %f\n%f, %f\n\n", a[0], a[2], a[1], a[3]);
  }

  Matrix22 operator -() const {
    return Matrix22(-a[0], -a[1], -a[2], -a[3]);
  }
};

int main(){
  Matrix22 m(1);
  m.print();
  (-m).print();
  m.print();
  return 0;
}