Addition +

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

2
2
2
2.000000

#include <stdio.h>

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

Siehe auch Subtraktions-Operator -

Details

Der Additions-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 Additions-Operator entspricht bei arithmetischen Typen grundsätzlich der mathematischen Addition, wobei man die beiden Operanden auch Terme nennt. Aufgrund der Rangordnung der Operatoren ist es möglich, einen Positiv- oder Negativ-Operator bei den beiden Termen direkt hinzuschreiben.

5
8
-10

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

Der Additions-Operator entspricht der direkten Umsetzung des entsprechenden Additions-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.

0

  unsigned int a = 4294967295;
  printf("%u\n",  a + 1);

Überladen des Operators

Der Additions-Operator hat grundsätzlich die semantische Bedeutung einer Addition im mathematischem Sinne. Allerdings gibt es Klassen, die eine andere Semantik definieren, beispielsweise die Addition zweier Strings, was in einem zusammengesetzten String resultiert. Auch weitere, ähnliche Anwendungen des Additions-Operators wären denkbar.

Die Prototypen für das Überladen des Additions-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 Positiv-Operators entspricht.

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

10.000000, 20.000000

13.000000, 26.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;
}