summaryrefslogtreecommitdiffhomepage
path: root/de-de
diff options
context:
space:
mode:
Diffstat (limited to 'de-de')
-rw-r--r--de-de/c-de.html.markdown54
1 files changed, 27 insertions, 27 deletions
diff --git a/de-de/c-de.html.markdown b/de-de/c-de.html.markdown
index 3dcb5ab9..9a938b22 100644
--- a/de-de/c-de.html.markdown
+++ b/de-de/c-de.html.markdown
@@ -75,7 +75,7 @@ int add_two_ints(int x1, int x2); // Funktionsprototyp
// Der Einstiegspunkt deines Programms ist eine Funktion mit dem Namen main und
// einem Integer als Rückgabewert.
-int main(void){
+int main(void) {
// dein Programm
}
@@ -87,7 +87,7 @@ int main(void){
// Argumente beinhaltet.
// argv[0] = Name des Programms
// argv[1] = erstes Argument usw.
-int main (int argc, char** argv){
+int main (int argc, char** argv) {
// Ausgabe mit Hilfe von printf (print formatted)
// %d ist ein Integer.
// \n steht für eine neue Zeile
@@ -303,19 +303,19 @@ int main (int argc, char** argv){
////////////////////////////////////////////////
// Kontrollstrukturen
////////////////////////////////////////////////
- if (0){
+ if (0) {
printf("Ich werde nie ausgeführt.");
}
- else if (0){
+ else if (0) {
printf("Ich werde auch nie ausgeführt.");
}
- else{
+ else {
printf("Ich gebe etwas aus.");
}
// While-Schleifen existieren auch
int ii = 0;
- while (ii < 10){ // JEDER Wert unter zehn ist wahr
+ while (ii < 10) { // JEDER Wert unter zehn ist wahr
printf("%d, " ii++); //i++ inkrementiert ii NACHDEM der Wert gebraucht
// wurde.
} // => gibt folgendes aus: "0, 1, 2, 3, 4, 5, 6, 7, 8, 9, "
@@ -323,16 +323,16 @@ int main (int argc, char** argv){
printf("\n");
int kk = 0;
- do{
+ do {
printf("%d, ", kk);
- }while(++kk < 10); //++kk inkrementiert kk BEVOR der Wert gebraucht wurde.
+ } while(++kk < 10); //++kk inkrementiert kk BEVOR der Wert gebraucht wurde.
// => gibt folgendes aus: "0, 1, 2, 3, 4, 5, 6, 7, 8, 9, "
printf("\n");
// In C gibt es auch for-Schleifen
int jj;
- for (jj = 0; jj < 10; jj++){
+ for (jj = 0; jj < 10; jj++) {
printf("%d, ", jj);
} // => gibt folgendes aus: "0, 1, 2, 3, 4, 5, 6, 7, 8, 9, "
@@ -342,14 +342,14 @@ int main (int argc, char** argv){
// Schleifen und Funktionen müssen einen Rumpf haben. Wenn kein Rumpf gebraucht
// wird, kann folgendes gemacht werden:
int i;
- for (i = 0; i <= 5; i++){
+ for (i = 0; i <= 5; i++) {
; // Semikolon wird als Rumpf behandelt (Null-Anweisung)
}
// Alternativ kann auch folgendes geschrieben werden:
for (i = 0; i <= 5; i++);
// Verzweigungen mit mehreren Möglichkeiten: `switch()`
- switch (a){
+ switch (a) {
case 0: // Labels müssen integrale *konstante* Ausdrücke sein (z.B. Enums)
printf("Hey, 'a' ist gleich 0!\n");
break; //Wenn du kein break einsetzt, so geht der Kontrollfluss
@@ -441,7 +441,7 @@ int main (int argc, char** argv){
int x_array[20]; // deklariert einen Array der Größe 20 (Größe kann
// nicht geändert werden.)
int xx;
- for (xx =0; xx < 20; xx++){
+ for (xx =0; xx < 20; xx++) {
x_array[xx] 20 -xx;
} // Initialisiere x_array zu 20, 19, 18, ... 2, 1
@@ -478,7 +478,7 @@ int main (int argc, char** argv){
// aus dem Heap - dies kann auf eingebetteten Systemen unterschiedlichen sein.
// Der C Standard sagt nichts darüber.)
int *my_ptr = malloc(sizeof(*my_ptr) * 20);
- for (xx = 0; xx < 20; xx++){
+ for (xx = 0; xx < 20; xx++) {
*(my_ptr + xx) = 20 -xx; //my_ptr[xx] = 20-xx
} // initialisiere Speicher zu 20, 19, 18, 17, ... 2, 1 (als `int`)
@@ -497,7 +497,7 @@ int main (int argc, char** argv){
// Füge dem Array ein Element hinzu
size++;
my_array = realloc(my_array, sizeof(int) *size);
- if (my_array == NULL){
+ if (my_array == NULL) {
// Denke daran, realloc-Fehler zu prüfen
return
}
@@ -538,7 +538,7 @@ int main (int argc, char** argv){
// Syntax einer Funktionsdeklaration
// <rueckgabe_wert> <funktions_name>(<args>)
-int add_two_ints(int x1, int x2){
+int add_two_ints(int x1, int x2) {
return x1 + x2; // verwendet return, um einen Wert zurückzugeben
}
@@ -555,14 +555,14 @@ Beispiel:
*/
// Eine `void`-Funktion gibt keinen Wert zurück
-void str_reverse(char *str_in){
+void str_reverse(char *str_in) {
char tmp;
size_t ii = 0;
size_t size = strlen(str_in);
// `strlen()` ist ein Teil der C Standard-Bibliothek.
// Merke: Die Länge, welche von `strlen` zurückgegeben wird, ist ohne den
// Null-Byte Terminator.
- for (ii = 0; i < size /2; ii++){ // in C99 kann man `ii` hier deklarieren.
+ for (ii = 0; i < size /2; ii++) { // in C99 kann man `ii` hier deklarieren.
tmp = str_in[ii];
str_in[ii] = str_in[size - ii - 1]; //#ii'tes Zeichen vom Ende her
str_in[size - ii- 1] = tmp;
@@ -579,7 +579,7 @@ printf("%s\n", c), => "tseT nie tsi saD"
// Weil wir lediglich eine Variable zurückgeben können, kann zum Ändern mehrerer
// Variablen das Konzept call-by-reference verwendet werden.
-void swap_two_numbers(int *a, int *b){
+void swap_two_numbers(int *a, int *b) {
int temp = *a;
*a = *b;
*b = temp;
@@ -600,9 +600,9 @@ Größe eines dynamischen Arrays herausgefunden werden kann.
*/
// Die Größe des Arrays muss unbedingt mitgegeben werden.
// Sonst hat die Funktion keine Ahnung wie groß das Array ist.
-void print_int_arrray(int *arr, size_t size){
+void print_int_arrray(int *arr, size_t size) {
int i;
- for (i = 0; i < size; i++){
+ for (i = 0; i < size; i++) {
printf("arr[%d] ist %d\n", i, arr[i]);
}
}
@@ -615,7 +615,7 @@ print_int_array(my_array, size);
// Wenn man auf externe Variable (außerhalb der Funktion) referenziert, sollte
// man das Schlüsselwort `extern` verwenden.
int i = 0;
-void test_function(){
+void test_function() {
extern int i; // i braucht nun die externe Variable i
}
@@ -643,7 +643,7 @@ my_type my_type_var = 0;
// Structs sind lediglich Sammlungen von Daten, die Inhalte werden
// (in der Reihenfolge wie sie geschrieben wurden) sequentiell alloziert.
-struct rectangle{
+struct rectangle {
int width;
int height;
};
@@ -653,7 +653,7 @@ struct rectangle{
// Dies ist so, weil potentiell ein Padding zwischen den Struktur-Inhalten
// möglich ist). (siehe [1, Englisch])
-void function_1(){
+void function_1() {
struct rectangle my_rectangle;
// Greife auf Struct-Inhalte mit `.` zu.
@@ -674,13 +674,13 @@ void function_1(){
// Aus Bequemlichkeitsgründen ist es möglich einem `struct` ein `typedef` hinzuzufügen.
typedef struct rectangle rect;
-int area(rect r){
+int area(rect r) {
return r.width * r.height;
}
// Wenn du große Structs hast, kannst du diese mit dem Pointer kopieren,
// damit große Kopiervorgänge vermieden werden.
-int area_ptr(const rect *r){
+int area_ptr(const rect *r) {
return r->width * r->height;
}
@@ -697,7 +697,7 @@ Wie auch immer, die Syntax kann zu Beginn verwirrend wirken.
Zum Beispiel: Verwende str_reverse von einem Pointer
*/
-void str_reverse_through_pointer(char *str_in){
+void str_reverse_through_pointer(char *str_in) {
// Definiere eine Funktionspointer-Variable, welche f genannt wird.
void (*f)(char *); // Signatur sollte genau der Funktion entsprechen.
f = &str_reverse; // weise die Adresse der wirklichen Funktion zu
@@ -823,7 +823,7 @@ befindet wie die C-Quelldatei.
// Strukturen und Typendefinitionen können verwendet werden, um die Konsistenz
// zwischen unterschiedlichen Dateien beizubehalten.
-typedef struct Node{
+typedef struct Node {
int value;
struct Node *next;
}Node;