Subtraktion -

Der Subtraktions-Operator führt eine Subtraktion zweier Elemente aus. Für arithmetische Typen entspricht dies der mathematischen Subtraktion zweier Zahlen.

4
-1
3
1.000000

#include <stdio.h>

int main(){
  int a = 4;
  int b = 5;
  float c = 3.f;
  printf("%d\n",  8 - 4);
  printf("%d\n",  a - b);
  printf("%d\n",  a - 1);
  printf("%f\n",  a - c);
  return 0;
}

Siehe auch Additions-Operator +

Details

Der Subtraktions-Operator erwartet zwei Operanden als rvalues und wird von links nach rechts abgearbeitet. Der Rückgabewert ist ein rvalue, dessen Typ grundsätzlich durch die arithmetische Umwandlung der beiden Operanden festgelegt ist.

Der Operator ist zulässig für arithmetische (Integer- und Fliesskomma-) Typen, den bool-Typ sowie Pointer. Boolsche Werte werden als Integer-Werte aufgefasst. Handelt es sich bei den Typen der beiden Operanden um Pointer-Typen, so wird nach den Regeln der Pointer-Arithmetik vorgegangen. Handelt es sich bei den Typen der beiden Operanden um arithmetische Typen, so wird gegebenfalls eine automatische arithmetische Umwandlung vorgenommen.

Der Subtraktions-Operator entspricht bei arithmetischen Typen grundsätzlich der mathematischen Subtraktion, wobei man den linken Operanden auch Minuend und den rechten Subtrahend nennt. Aufgrund der Rangordnung der Operatoren ist es möglich, einen Positiv- oder Negativ-Operator bei den beiden Operanden direkt hinzuschreiben.

15
2
0

  int a = 5;
  printf("%d\n",  10 - -a);
  printf("%d\n",  a  - +3);
  printf("%d\n",  -a - -a);

Der Subtraktions-Operator entspricht der direkten Umsetzung des entsprechenden Subtraktions-Befehls in Assembler und kann somit für arithmetische Typen einen Over- oder Underflow ergeben, was bei Integer-Typen zu einem Wrap-Around führt.

4294967295

  unsigned int a = 0;
  printf("%u\n",  a - 1);

Überladen des Operators

Der Subtraktions-Operator hat grundsätzlich die semantische Bedeutung einer Subtraktion im mathematischem Sinne. Allerdings gibt es Klassen, die eine andere Semantik definieren, beispielsweise die Subtraktion eines Characters von einem String, was in einem sogenannt getrimmten String resultiert (sämtliche Vorkommen des Characters am Anfang und Ende des Strings werden entfernt). Auch weitere, ähnliche Anwendungen des Subtraktions-Operators wären denkbar.

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

inside class


outside class

Type operator -(Type);
Type operator -(Type) const;

Type operator -(Type, Type);

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

Im folgenden Beispiel wird eine Klasse präsentiert für einen zweidimensionalen Vektor. Gemäss der Vektoralgebra wird eine Subtraktion zweier Vektoren als die komponentenweise Subtraktion der Vektorfelder beschrieben.

10.000000, 20.000000

7.000000, 14.000000

#include <cstdio>

class Vector2{
  float a[2];
public:
  Vector2(float x, float y){a[0]=x; a[1]=y;}
  void print(){printf("%f, %f\n", a[0], a[1]);}
  
  Vector2 operator -(Vector2& t) const {
    return Vector2(a[0] - t.a[0], a[1] - t.a[1]);
  }
};

int main(){
  Vector2 v1(10, 20);
  Vector2 v2(3, 6);
  v1.print();
  v1 = v1 - v2;
  v1.print();
  return 0;
}