diff options
| -rw-r--r-- | de-de/c-de.html.markdown | 141 |
1 files changed, 138 insertions, 3 deletions
diff --git a/de-de/c-de.html.markdown b/de-de/c-de.html.markdown index 777bba11..69576da0 100644 --- a/de-de/c-de.html.markdown +++ b/de-de/c-de.html.markdown @@ -144,12 +144,147 @@ int main (int argc, char** argv){ // Gibt "sizeof(a++) = 4, wobei a=1 ist" aus (mit einer 32-Bit-Architektur) // Arrays müssen mit einer Grösse initialisiert werden. - char my_char_array[20]; // Dieses Array beinhaltet 1 * 20 = 20 Bytes - int my_int_array[20]; // Dieses Array beinhaltet 4 * 20 = 80 Bytes. + char mein_char_array[20]; // Dieses Array beinhaltet 1 * 20 = 20 Bytes + int mein_int_array[20]; // Dieses Array beinhaltet 4 * 20 = 80 Bytes. // unter der Voraussetzung eines 4-Byte-Worts. // Ein Array kann auf diese Weise mit 0 initialisiert werden. - char my_array[20] = {0}; + char mein_array[20] = {0}; // Hierbei ist der Teil "{0}" der "Array Initialisierer". + // Beachte, dass die Länge des Arrays nicht explizit definiert werden muss, + // wenn er auf derselben Linie initialisiert wird. + // Folgende Deklaration ist gleichwertig: + char mein_array[] = {0}; + // Allerdings muss die Länge des Arrays dann zur Laufzeit ausgewertet werden: + size_t mein_array_size = sizeof(mein_array) / sizeof(mein_array[0]); + // WARNUNG: Wenn dieser Ansatz gewählt wird, muss man sicherstellen, dass die + // Grösse des Arrays ermittelt werden *bevor* dieser einer Funktion als + // Argument weitergegeben wird (siehe Diskussion weiter unten), weil Arrays + // einer Funktion nur als Zeiger übergeben werden. => Das obere Statement + // würde innerhalb einer Funktion ein falsches Resultat liefern. + + // Das Indexieren eines Arrays funktioniert wie in anderen Sprache - resp. + // in anderen Sprachen funktioniert es gleich wie in C. + mein_array[0]; // => 0 + + // Arrays sind veränderbar; es ist nur Arbeitsspeicher! + mein_array[1] = 2; + printf("%d\n", mein_array[1]); // => 2 + + // In C99 (und als optionales Feature in C11) können Arrays mit variabler + // Länge deklariert werden. Die Grösse eines solchen Array muss eine Konstante + // zur Kompilierzeit sein. + printf("Geben Sie die Arraygrösse an: "); //Frag den Benutzer nach der Arraygrösse + int array_size; + fcsanf(stdin, "%d", &array_size); + int var_length_array[array_size]; // deklariere Array mit variabler Länge + printf("sizeof array =%zu\n", sizeof var_length_array); + + // Zum Beispiel: + // > Geben Sie die Arraygrösse an: 10 + // > sizeof array = 40 + + // Strings sind lediglich Arrays von `chars`, welche mit einem Null-Byte + // (0x00) beendet werden. In Strings wird das Nullbyte durch das Zeichen \0 + // repräsentiert. Wir müssen das Null-Byte nicht angeben in String-Literalen; + // Der Compiler fügt es am Ende des Array automatisch hinzu. + char ein_string[20] = "Das ist ein String"; + printf("%s\n", ein_string); // %s formattiert einen String + + printf("%d\n", ein_string[18]); // => 0 + // Hier ist das Byte #19 0 (wie auch Byte #20) + + // Wenn wir Zeichen zwischen einfachen Anführungszeichen haben, ist es ein + // Zeichenliteral vom Typ int und *nicht* char. (aus historischen Gründen) + int cha = 'a'; // Ok + char chb = 'a'; // auch ok (implizite Umwandlung von int zu char) + + // Mehrdimensionale Arrays: + int multi_array[2][5] = { + {1,2,3,4,5}, + {6,7,8,9,0} + }; + // Auf Elemente zugreifen: + 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 to 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 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 Linksshift (left shift) (um 1)) + 0x02 >> 1; // => 0x01 (Bitweises Rechtsshift (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. + } |