Division /

Der Divisions-Operator führt eine Division zweier Elemente aus. Für arithmetische Typen mit Dezimalpunkt entspricht dies der mathematischen Division zweier Zahlen. Bei Integer-Typen entspricht dies der ganzzahligen Division ohne Rest.

5
4
4
4.800000

#include <stdio.h>

int main(){
  int a = 24;
  int b = 6;
  printf("%d\n",  10 / 2);
  printf("%d\n",  a / b);
  printf("%d\n",  24   / 5  );
  printf("%f\n",  24.0 / 5.0);
  return 0;
}

Siehe auch Multiplikations-Operator *, Modulo-Operator %

Details

Der Divisions-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 sowie den bool-Typ. Boolsche Werte werden als Integer-Werte aufgefasst. Die Operanden werden gegebenfalls entsprechend den Regeln der arithmetischen Umwandlung gecastet.

Der Divisions-Operator entspricht bei arithmetischen Typen grundsätzlich der mathematischen Division, wobei man die beiden Operanden auch Dividend und Divisor nennt. Wenn mittels des Divisions-Operators jedoch zwei Integer-Werte verknüpft werden, handelt es sich um die ganzzahlige Division ohne Rest. Dies kann manchmal zu schwer auffindbaren Fehlern führen, wenn Fliesskommazahlen mit Integer-Zahlen vermischt in einer Berechnung auftreten. In diesem Falle hilft oftmals ein explizites Casting.

0.000000, 0.000000
0.000000, 3.141590
6.283180, 6.283180
6.283180, 9.424770
12.566360, 12.566360
12.566360, 15.707950
18.849540, 18.849540
18.849540, 21.991130

#include <stdio.h>
#define PI 3.14159

int main(){
  int substeps = 2;
  int numperiods = 4;
  int i;
  for(i = 0; i < numperiods * substeps; i++){
    printf("%f, ", 2 * PI * (       i / substeps));
    printf("%f\n", 2 * PI * ((float)i / substeps));
  }
  return 0;
}

Aufgrund der Rangordnung der Operatoren ist es möglich, einen Positiv- oder Negativ-Operator bei den beiden Operanden direkt hinzuschreiben.

-5.000000
4.000000
1.000000

  float a = 20;
  printf("%f\n",  100 / -a);
  printf("%f\n",  a   / +5);
  printf("%f\n",  -a  / -a);

Eine Division durch 0 ist, wie in der Mathematik festgelegt, nicht zulässig. Wenn bereits beim Compilieren eine solche Division erkannt wird, gibt der Compiler eine division by zero-Warnung aus. Tritt während der Laufzeit des Programmes eine solche Division auf, so wird dem Programm normalerweise das Signal 8 (SIGFPE: Floating Point Error) gesendet, was ohne entsprechende Behandlung zum Abbruch des Programmes führt. Bei Fliesskommatypen kann es jedoch sein, dass die Division durch 0 zum Ergebnis Unendlich führt.

division by zero -> SIGFPE
inf

  printf("%d\n", 1  / 0 );
  printf("%f\n", 1. / 0.);

Bei Fliesskomma-Typen kann auch eine Division durch nicht-Null zum Wert Unendlich führen. Die Division 0. / 0. ergibt den Wert nan (not a number). Die Division inf / inf ergibt ebenfalls nan, wohingegen jede andere Division durch Unendlich den Wert 0 ergibt. Anmerkung: Die Definition des Makros INFINITY befindet sich in der Datei math.h

inf
nan
nan
0.000000

  printf("%f\n", 1e200  / 1e-200 );
  printf("%f\n", 0. / 0.);
  printf("%f\n", INFINITY / INFINITY);
  printf("%f\n", 1e200 / INFINITY);

Überladen des Operators

Der Divisions-Operator hat grundsätzlich die semantische Bedeutung einer Division im mathematischem Sinne. Allerdings gibt es Klassen, die eine andere Semantik definieren, beispielsweise die Verwandlung von Strings in Teilstrings welche im ursprünglichen String durch ein bestimmtes ASCII-Zeichen getrennt sind. Auch weitere, ähnliche Anwendungen des Divisions-Operators wären denkbar.

Die Prototypen für das Überladen des Divisions-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);

Im folgenden Beispiel wird eine Klasse präsentiert für einen zweidimensionalen Vektor. Gemäss der Vektoralgebra wird eine Division eines Vektors mit einem Skalar als die komponentenweise Division der Vektorfelder beschrieben.

10.000000, 20.000000

5.000000, 10.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 /(float s) const {
    return Vector2(a[0] / s, a[1] / s);
  }
};

int main(){
  Vector2 v1(10, 20);
  v1.print();
  v1 = v1 / 2.;
  v1.print();
  return 0;
}