Die Division in C++

Einführendes Beispiel

Die Division wird mit einem Schrägstrich »/« geschrieben. Der Schrägstrich »/« sollte nicht mit dem inversen Schrägstrich »\« verwechselt werden!

main.cpp

#include <iostream>
#include <ostream>
#include <string>
using namespace ::std::literals;
int main() { ::std::cout << 70/10 << "\n"s; }

transcript

C++

70/10

auf deutsch

70 geteilt durch 10

in der Mathematik

70 ÷ 10

70 : 10

70∕10

 
 70
----
 10

Syntax

Neue, erweiterte Syntax

Divisionsausdruck
    .--------------------.     .-.     .--------------------.
--->| Vorzeichenausdruck |--->( / )--->| Vorzeichenausdruck |--->
    '--------------------'     '-'     '--------------------'

Wir hatte einen Operator bisher als ein Zeichen kennengelernt, das mit einem Operanden zusammen geschrieben wird. Nun erweitern wir den Begriff dahingehend, daß ein Operator auch zwei Operanden haben kann. Der Divisionsoperator wird zwischen seine beiden Operanden geschrieben.

Begriffe der Division

Sind D und d zwei Vorzeichenausdrücke, so ist D /d ein Divisionsausdruck, der Quotient von D und d. Dabei wird D auch Dividend und d Divisor (diˈviːzoːʌ̯) genannt: „Dividend/Divisor“.

Begriffe zu Operatoren

Der Operator »/« hat zwei Operandenstellen (eine linke und eine rechte). Er wird daher binär genannt, während die zuvor vorgestellten Operatoren unär waren (sie hatten nur einen Operandenausdruck). Weil dieser Operator zwischen seinen Operandenausdrücken steht, wird er auch als ein Infixoperator bezeichnet.

Entsprechend bezeichnen wir einen Vorzeichenausdruck von nun an auch als einen unären Ausdruck.

Neue, verbesserte Syntax

Divisionsausdruck
    .------------------.     .-.     .------------------.
--->| unaerer Ausdruck |--->( / )--->| unaerer Ausdruck |--->
    '------------------'     '-'     '------------------'

Typanforderungen

Der Dividend und der Divisor müssen beide jeweils numerisch sein (keiner von beiden darf also den Typ ›::std::string‹ haben).

Verwendung mit gleichen Typen

Dieser Operator kann mit double - und mit int -Werten verwendet werden.

Zunächst betrachten wir Fälle, in denen beide Operandenausdrücke ›double‹ oder beide ›int‹ sind.

main.cpp

#include <iostream>
#include <ostream>
#include <string>
using namespace ::std::literals;
int main() { ::std::cout << 1./2. << "\n"s; }

transcript

0.5

main.cpp

#include <iostream>
#include <ostream>
#include <string>
using namespace ::std::literals;
int main() { ::std::cout << 1/2 << "\n"s; }

transcript

Sind beide Operandenausdrücke int, bedeutet der Operator die „ganzzahlige Division“. Dabei werden die Nachkommastellen des Ergebnisses, das sich bei einer normalen Division ergeben würde, abgeschnitten.

Verwendung mit verschiedenen Typen

Bei einer Mischung int /double oder double /int wird der int -Wert in den ihn entsprechenden double -Wert uminterpretiert (aus dem int -Wert «2» wird beispielsweise der double -Wert «2.0».)

main.cpp

#include <iostream>
#include <ostream>
#include <string>
using namespace ::std::literals;
int main() { ::std::cout << 1./2 << "\n"s; }

transcript

0.5

main.cpp

#include <iostream>
#include <ostream>
#include <string>
using namespace ::std::literals;
int main() { ::std::cout << 1/2. << "\n"s; }

transcript

0.5

Typ der Division

int /double → double /double = double

double /int → double /double = double

Dieses Prinzip wird auch bei den anderen Operatoren für die Grundrechenarten angewendet, die wir in diesem Kapitel noch kennenlernen werden.

Typregeln

Ist der Typ des einen Operanden ›double‹, so wird der Wert des anderen Operand nach ›double‹ gewandelt und der Typ des gesamten Ausdrucks hat den Typ ›double‹. Sonst hat der gesamte Ausdruck den Typ ›int‹. (Diese Beschreibung berücksichtigt nur die bisher vorgestellten Typen.)

Typregeln

mindestens ein double -Operand → Ergebnis double
nur int -Operanden → Ergebnis int

Typregeln (andere Formulierung)

double /double → double
double /int → double
int /double → double
int /int → int

Die Auswertung einer Division ⃗

Bei der Auswertung einer Division werden beide Operanden ausgewertet. Der Wert einer double /double -Division ist (bis auf meist kleine Abweichungen) der normale Quotient der beiden Werte, der Wert einer int /int -Division jedoch nur der ganzzahlige Anteil dieses Quotienten (der Teil vor dem Dezimaltrennzeichen).

(Der ganzzahlige Anteil einer Division ‹x ∕y › wird in der Mathematik auch als ‹x ∖ y › geschrieben.)

Priorität

Der Vorzeichenwechsel hat eine höhere Priorität als die Division. Dies heißt, daß der Vorzeichenwechseloperator in »-3/2« sich nur auf die »3« bezieht und nicht etwas auf den gesamten Bruch.

Bei der Auswertung von »-3/2« wird zuerst der Vorzeichenwechsel und dann die Division ausgeführt.

In der folgenden Tabelle zur Priorität von Operatoren finden sich Operatoren mit höherer Priorität weiter oben.

Priorität der bisher behandelten Operatoren

+  -                 Unaere vorangestellte Operatoren
/                    Division

Beispiele zur ganzzahligen Division

Diese Beispiele zur ganzzahligen Division sollen illustrieren, wann die ganzzahlige Division benötigt wird.

Beispiel Die ganzzahligen Division

Beim Programmieren kommt es manchmal vor, daß eine Zahl in ihre Stellen zerlegt werden soll.

Bei einer zweistelligen Zahl, wie ‹ 27 ›, erhält man die Zehnerstelle durch ganzzahlige Division durch 10.

Beispiel Die ganzzahligen Division (1) ⃗

Aus einer Sequenz von Dingen soll eines ausgewählt werden, das möglichst nahe an der Mitte liegt. Bei einer geraden Anzahl von Dingen gibt es aber kein bestimmtes mittleres Ding. Die ganzzahlige Division der Anzahl der Dinge durch zwei liefert hier dann aber immer eine brauchbare Näherung an die mittlere Position, während ein Ergebnis mit Nachkommastellen hier nicht nützlich wäre, da eine Positionszahl (die sich aus der Durchnumerierung von Positionen ergibt) nie Nachkommastellen hat.

Eine möglichst mittlere Position in einer Reihe festlegen

v
6 0 1 2 3 4 5 6 / 2 = 3

v
7 0 1 2 3 4 5 6 7 / 2 = 3

v
8 0 1 2 3 4 5 6 7 8 / 2 = 4

v
9 0 1 2 3 4 5 6 7 8 9 / 2 = 4

Beispiel Die ganzzahligen Division (2) ⃗

Auch dieses Beispiel soll illustrieren, wann die ganzzahlige Division benötigt wird.

47 Flaschen sollen in Kartons verpackt werden, die jeweils vier Flaschen aufnehmen können. Alle Kartons müssen immer vollständig mit jeweils vier Flaschen gefüllt werden, es ist also nicht erlaubt, daß ein Karton nur teilweise gefüllt wird. Wie viele Kartons können gefüllt werden?

Abbildung von 47 Flaschen

o o o o o o o o o o o o o o o o o o o o o o o o
o o o o o o o o o o o o o o o o o o o o o o o

Abbildung von leeren Kartons

·|·  ·|·  ·|·  ·|·  ·|·  ·|·  ·|·  ·|·  ·|·  ·|·  ·|·  ·|·  ·|·  ·|·  ·|·
-|-  -|-  -|-  -|-  -|-  -|-  -|-  -|-  -|-  -|-  -|-  -|-  -|-  -|-  -|-
·|·  ·|·  ·|·  ·|·  ·|·  ·|·  ·|·  ·|·  ·|·  ·|·  ·|·  ·|·  ·|·  ·|·  ·|·

Abbildung elf gefüllter Kartons

o|o  o|o  o|o  o|o  o|o  o|o  o|o  o|o  o|o  o|o  o|o    o o
-|-  -|-  -|-  -|-  -|-  -|-  -|-  -|-  -|-  -|-  -|-
o|o  o|o  o|o  o|o  o|o  o|o  o|o  o|o  o|o  o|o  o|o    o
                                                         ·|·  ·|·  ·|·  ·|·
                                                         -|-  -|-  -|-  -|-
                                                         ·|·  ·|·  ·|·  ·|·

main.cpp

#include <iostream>
#include <ostream>
#include <string>
using namespace ::std::literals;
int main() { ::std::cout << 47 / 4 << "\n"s; }

transcript

Es können elf Kartons gefüllt werden.

Zum Vergleich folgt hier noch die Berechung mit den hier nicht interessierenden Nachkommastellen.

main.cpp

#include <iostream>
#include <ostream>
#include <string>
using namespace ::std::literals;
int main() { ::std::cout << 47.0 / 4.0 << "\n"s; }

transcript

11.75