summaryrefslogtreecommitdiffhomepage
path: root/de-de/c-de.html.markdown
diff options
context:
space:
mode:
authorcaminsha <c.96marco@hotmail.com>2020-02-02 21:25:23 +0100
committercaminsha <c.96marco@hotmail.com>2020-02-02 21:25:23 +0100
commit8ab886330e8cf8dc19301d16155c849371f35e66 (patch)
tree133758fc967ac3f1ed974e77def2c3a402ad497d /de-de/c-de.html.markdown
parentec76a960a6e9f04b5fe75faa7301d5fa5eed7fdb (diff)
reordered section about operators and changed variables to numbers
Diffstat (limited to 'de-de/c-de.html.markdown')
-rw-r--r--de-de/c-de.html.markdown165
1 files changed, 83 insertions, 82 deletions
diff --git a/de-de/c-de.html.markdown b/de-de/c-de.html.markdown
index fceec5d4..e493a303 100644
--- a/de-de/c-de.html.markdown
+++ b/de-de/c-de.html.markdown
@@ -89,6 +89,89 @@ int main (int argc, char** argv){
printf("%d\n",0); // => Gibt 0 aus.
////////////////////////////////////////////////
+ // Operatoren
+ ////////////////////////////////////////////////
+
+ // Kurzschreibweise für mehrere Deklarationen
+ int i1 = 1, i2 = 2;
+ flaot f1 = 1.0, f2 = 2.0;
+
+ int b,c;
+ b = c = 0;
+
+ // Arithmetik ist unkompliziert
+ 1 + 2; // => 3
+ 2 - 1; // => 1
+ 2 * 1; // => 2
+ 1 / 2; // 0 (0.5, aber abgeschnitten, da es int sind.)
+
+ // Man muss mindestens ein Integer zu einen float konvertieren, damit man als
+ // Resultat eine Gleitkommazahl erhält.
+ (float)1 / 2; // => 0.5f
+ 1 / (double)2; // => 0.5 // das gleiche mit dem Typ `double`
+ 1.0 / 2.0; // => 0.5, plus oder minus Epsilon
+ // Gleitkommazahlen und deren Berechnungen sind nicht exakt.
+
+ // Es gibt auch die Möglichkeit, Modulo zu rechnen
+ 11 % 3; // => 2
+
+ // Vergleichsoperatoren sind vielleicht schon bekannt, aber in C gibt es
+ // keinen Boolean-Typ. In C verwenden wir `int`. (Oder _Bool oder bool in C99)
+ // 0 ist falsch, alles andere ist wahr (Die Vergleichsoperatoren ergeben
+ // immer 1 oder 0.
+ 3 == 2; // => 0 (falsch)
+ 3 != 2; // => 1 (wahr)
+ 3 > 2; // => 1
+ 3 < 2; // => 0
+ 2 <= 2; // => 1
+ 2 >= 2; // => 1
+
+ // C ist nicht Python - Vergleiche können nicht einfach verkettet werden.
+ // Warnung: die folgende Zeile wird kompilieren, aber es bedeutet `(0 < a) < 2`.
+ // Dieser Ausdruck ist immer wahr, weil (0 < a) kann entweder 1 oder 0 sein.
+ // In diesem Falle ist es 1, weil (0 < 1).
+ int zwischen_0_und_2 = 0 < a < 2;
+ // Benutze stattdessen folgende Schreibweise:
+ int zwischen_0_und_2 = 0 < a && a < 2;
+
+ // Logik funktioniert auch mit ints
+ !3; // => 0 (logisches Nicht)
+ !0; // => 1
+ 1 && 1; // => 1 (logisches Und)
+ 0 && 1; // => 0
+ 0 || 1; // => 1 (logisches Oder)
+ 0 || 0; // => 0
+
+ // Bedingter ternärer Ausdruck ( ? : )
+ int e = 5;
+ int f = 10;
+ int z;
+ z = ( e > f ) ? e : f; // => // => 10 "wenn e > f ist, gib e zurück, sonst f."
+
+ // Inkrementierungs- und Dekrementierungsoperatoren
+ int j = 0;
+ int s = j++; // gib j zurück und erhöhe danach j. (s = 0, j = 1)
+ s = ++j; // erhöhe zuerst j und gib dann j zurück (s = 2, j = 2)
+ // das gleiche gilt für j-- und --j
+
+ // Bitweise Operatoren
+ ~0x0F; // => 0xFFFFFFF0 (Bitweise Negation, "Einer-Komplement",
+ // Beispielresultat für 32-Bit int)
+ 0x0F & 0xF0; // => 0x00 (Bitweises UND)
+ 0x0F | 0xF0; // => 0xFF (Bitweises ODER)
+ 0x04 ^ 0x0F; // => 0x0B (Bitweises XOR)
+ 0x01 << 1; // => 0x02 (Bitweises Linksverschiebung (left shift) (um 1))
+ 0x02 >> 1; // => 0x01 (Bitweises Rechtsverschiebung (right shift) (um 1))
+
+ // Sei vorsichtig beim Shift mit vorzeichenbehafteten Integern
+ // folgende Ausdrücke sind nicht definiert:
+ // - Verschiebung in das Vorzeichenbit (int a = 1 << 31)
+ // - Linksshift einer negativen Zahl (int a = -1 << 2)
+ // - Shift um einen Offset, welcher >= die Breite des linken Ausdrucks ist.
+ // int a = 1 << 32; // undefiniertes Verhalten, wenn int 32-Bit ist.
+
+
+ ////////////////////////////////////////////////
// Typen
////////////////////////////////////////////////
@@ -213,88 +296,6 @@ int main (int argc, char** argv){
int array_int = multi_array[0][2]; // => 3
////////////////////////////////////////////////
- // Operatoren
- ////////////////////////////////////////////////
-
- // Kurzschreibweise für mehrere Deklarationen
- int i1 = 1, i2 = 2;
- flaot f1 = 1.0, f2 = 2.0;
-
- int b,c;
- b = c = 0;
-
- // Arithmetik ist unkompliziert
- i1 + i2; // => 3
- i2 - i1; // => 1
- i2 * i1; // => 2
- i1 / i2; // 0 (0.5, aber abgeschnitten, da es int sind.)
-
- // Man muss mindestens ein Integer zu einen float konvertieren, damit man als
- // Resultat eine Gleitkommazahl erhält.
- (float)i1 / i2; // => 0.5f
- i1 / (double)i2; // => 0.5 // das gleiche mit dem Typ `double`
- f1 / f2; // => 0.5, plus oder minus Epsilon
- // Gleitkommazahlen und deren Berechnungen sind nicht exakt.
-
- // Es gibt auch die Möglichkeit, Modulo zu rechnen
- 11 % 3; // => 2
-
- // Vergleichsoperatoren sind vielleicht schon bekannt, aber in C gibt es
- // keinen Boolean-Typ. In C verwenden wir `int`. (Oder _Bool oder bool in C99)
- // 0 ist falsch, alles andere ist wahr (Die Vergleichsoperatoren ergeben
- // immer 1 oder 0.
- 3 == 2; // => 0 (falsch)
- 3 != 2; // => 1 (wahr)
- 3 > 2; // => 1
- 3 < 2; // => 0
- 2 <= 2; // => 1
- 2 >= 2; // => 1
-
- // C ist nicht Python - Vergleiche können nicht einfach verkettet werden.
- // Warnung: die folgende Zeile wird kompilieren, aber es bedeutet `(0 < a) < 2`.
- // Dieser Ausdruck ist immer wahr, weil (0 < a) kann entweder 1 oder 0 sein.
- // In diesem Falle ist es 1, weil (0 < 1).
- int zwischen_0_und_2 = 0 < a < 2;
- // Benutze stattdessen folgende Schreibweise:
- int zwischen_0_und_2 = 0 < a && a < 2;
-
- // Logik funktioniert auch mit ints
- !3; // => 0 (logisches Nicht)
- !0; // => 1
- 1 && 1; // => 1 (logisches Und)
- 0 && 1; // => 0
- 0 || 1; // => 1 (logisches Oder)
- 0 || 0; // => 0
-
- // Bedingter ternärer Ausdruck ( ? : )
- int e = 5;
- int f = 10;
- int z;
- z = ( e > f ) ? e : f; // => // => 10 "wenn e > f ist, gib e zurück, sonst f."
-
- // Inkrementierungs- und Dekrementierungsoperatoren
- int j = 0;
- int s = j++; // gib j zurück und erhöhe danach j. (s = 0, j = 1)
- s = ++j; // erhöhe zuerst j und gib dann j zurück (s = 2, j = 2)
- // das gleiche gilt für j-- und --j
-
- // Bitweise Operatoren
- ~0x0F; // => 0xFFFFFFF0 (Bitweise Negation, "Einer-Komplement",
- // Beispielresultat für 32-Bit int)
- 0x0F & 0xF0; // => 0x00 (Bitweises UND)
- 0x0F | 0xF0; // => 0xFF (Bitweises ODER)
- 0x04 ^ 0x0F; // => 0x0B (Bitweises XOR)
- 0x01 << 1; // => 0x02 (Bitweises Linksverschiebung (left shift) (um 1))
- 0x02 >> 1; // => 0x01 (Bitweises Rechtsverschiebung (right shift) (um 1))
-
- // Sei vorsichtig beim Shift mit vorzeichenbehafteten Integern
- // folgende Ausdrücke sind nicht definiert:
- // - Verschiebung in das Vorzeichenbit (int a = 1 << 31)
- // - Linksshift einer negativen Zahl (int a = -1 << 2)
- // - Shift um einen Offset, welcher >= die Breite des linken Ausdrucks ist.
- // int a = 1 << 32; // undefiniertes Verhalten, wenn int 32-Bit ist.
-
- ////////////////////////////////////////////////
// Kontrollstrukturen
////////////////////////////////////////////////
if (0){