Arithmetische Operatoren in Dart

Grundlegende binäre arithmetische Operatoren

Dienen zur Berechnung zwischen zwei Zahlenwerten, es gibt insgesamt 7 Typen. Darunter fallen die vier Grundrechenarten, Ganzzahldivision, Restberechnung und der unäre Minusoperator.

Operator	Beschreibung der Funktion
+	Addition
-	Subtraktion
-Ausdruck	Unäres Minus (Vorzeichenwechsel, kehrt das Vorzeichen einer Zahl um)
*	Multiplikation
/	Normale Division, Ergebnis ist immer vom Typ double (Gleitkommazahl)
~/	Ganzzahldivision, schneidet den Nachkommabereich ab und gibt einen int zurück
%	Modulo (ermittelt den Rest der Ganzzahldivision)

Die Division hat im Vergleich zu anderen Programmiersprachen eine Besonderheit: Der Operator / liefert immer eine Gleitkommazahl. Wenn ein Ganzzahlergebnis benötigt wird, muss ~/ verwendet werden. Das ist ein wichtiger Hinweis für Leser mit Programmiererfahrung.

Code-Beispiel:

void main() {
        // Überprüfung von Addition, Subtraktion, Multiplikation, Division, Ganzzahldivision und Modulo
	print(2 + 3 == 5);
	print(2 - 3 == -1);
	print(2 * 3 == 6);
	print(5 / 2 == 2.5);  // Normale Division gibt double-Gleitkommazahl aus
	print(5 ~/ 2 == 2);   // Ganzzahldivision behält nur den ganzzahligen Teil (int)
	print(5 % 2 == 1);    // % Modulo-Operator liefert ausschließlich den Rest der Ganzzahldivision

	// Beispiel für String-Verkettung mit Quotient und Rest
	print('5/2 = ${5 ~/ 2} r ${5 % 2}' == '5/2 = 2 r 1');
}Code-Sprache: Dart (dart)

Bild mit dem Ausführungsergebnis

Inkrement / Dekrement Operatoren

Dart unterstützt zwei Varianten: Präfix und Postfix für Inkrement ++ und Dekrement --. Der entscheidende Unterschied: Wird die Variable zuerst verändert oder zuerst ihr ursprünglicher Wert verwendet?

Operator	Ausführungslogik	Rückgabewert des Ausdrucks
++var	Variable zuerst um 1 erhöhen, dann neuen Wert für Berechnungen nutzen	Neuer Wert nach dem Inkrement
var++	Ursprünglichen Variablenwert zuerst für Berechnung nutzen, danach Variable um 1 erhöhen	Ursprungswert vor dem Inkrement
--var	Variable zuerst um 1 verringern, dann neuen Wert für Berechnungen nutzen	Neuer Wert nach dem Dekrement
var--	Ursprünglichen Variablenwert zuerst für Berechnung nutzen, danach Variable um 1 verringern	Ursprungswert vor dem Dekrement

void main() {
	int a;
	int b;

	// 1. Präfix-Inkrement ++a: Zuerst erhöhen, dann zuweisen
	a = 0;
	b = ++a;
	print(a == b); // a=1, b=1 → true

	// 2. Postfix-Inkrement a++: Zuerst alten Wert zuweisen, dann erhöhen
	a = 0;
	b = a++;
	print(a != b); // a=1, b=0 → true

	// 3. Präfix-Dekrement --a: Zuerst verringern, dann zuweisen
	a = 0;
	b = --a;
	print(a == b); // a=-1, b=-1 → true

	// 4. Postfix-Dekrement a--: Zuerst alten Wert zuweisen, dann verringern
	a = 0;
	b = a--;
	print(a != b); // a=-1, b=0 → true
}
Code-Sprache: PHP (php)

Alle Ausgaben im Beispiel ergeben true.

Wichtiger Hinweis: Die Position von ++ oder — (vor oder nach der Variable) führt in Ausdrücken zu unterschiedlichem Verhalten.

Bei alleiniger Verwendung, Beispiel:

int a = 1;
++a;

int b  = 1;
b++;

print(a);
print(b);Code-Sprache: PHP (php)

Der obige Code gibt am Ende für beide Variablen 2 aus.

D:\dartdemo\firstdart>dart run
Building package executable...
Built firstdart:firstdart.
2
2
Code-Sprache: CSS (css)

Dasselbe gilt für –: Die Variable wird am Ende stets um +1 oder -1 verändert.

Wenn ++ / — aber innerhalb einer Rechenformel vorkommt, Beispiel:

void main() {
  int a = 5;
  // Postfix: Zuerst mit dem Wert 5 rechnen, danach a auf 6 setzen
  int res1 = a++ * 2;
  print(res1); // 10
  print(a);  // 6

  int b= 5;
  // Präfix: Zuerst b auf 6 setzen, dann damit rechnen
  int res2 = ++b * 2;
  print(res2); // 12
  print(b); // 6
}Code-Sprache: PHP (php)

a und b haben am Ende beide den Wert 6, res1 und res2 liefern aber unterschiedliche Ergebnisse – nur durch die andere Position des ++.

Erklärung Postfix a++: Zuerst wird a*2=10 mit dem Wert a=5 berechnet, das Ergebnis an res1 übergeben, danach wird a um 1 auf 6 erhöht.

Beim Präfix ++b wird zuerst b um 1 auf 6 erhöht, anschließend die Rechnung 6*2=12 ausgeführt und an res2 zugewiesen.

Die Zeile int res1 = a++ * 2; lässt sich aufteilen in:

int res1 = a * 2;
a = a +1;

Die Zeile int res2 = ++b * 2; lässt sich aufteilen in:

b = b+1;
int res2 = b * 2;

Einfache Merkregel zum Merken:

Präfix zuerst ändern, Postfix zuerst verwenden;

Präfix gibt neuen Wert zurück, Postfix gibt alten Wert zurück.

Zusammenfassung

Präfix ++a / --a: Zuerst die Variable verändern, dann den veränderten Wert für Berechnungen oder Zuweisungen nutzen

Postfix a++ / a--: Zuerst den ursprünglichen Variablenwert für Berechnungen oder Zuweisungen nutzen, nach Abschluss der Operation die Variable verändern

Sie können die folgenden Beispiele ausprobieren:

void main() {
  int a = 0;
  int b = ++a; 
  // Schritt1: a = a + 1 → a wird 1
  // Schritt2: Den neuen Wert a (1) an b zuweisen
  print(a); // 1
  print(b); // 1
}

void main() {
  int a = 0;
  int b = a++;
  // Schritt1: Den alten Wert von a (0) an b zuweisen
  // Schritt2: Ausführen a = a + 1 → a wird 1
  print(a); // 1
  print(b); // 0
}

void main() {
  int a = 0;
  int b = --a;
  // Schritt1: a = a - 1 → a wird -1
  // Schritt2: Den neuen Wert a (-1) an b zuweisen
  print(a); // -1
  print(b); // -1
}

void main() {
  int a = 0;
  int b = a--;
  // Schritt1: Den alten Wert von a (0) an b zuweisen
  // Schritt2: Ausführen a = a - 1 → a wird -1
  print(a); // -1
  print(b); // 0
}

Das sind die einfachsten Beispiele für Präfix- und Postfix-Inkrement/Dekrement. Kompilieren und führen Sie den Code selbst aus, um den Unterschied zu erkennen.