Selbsttest C-Programmierung

Lösung:

int result = 17 / 5;
printf("%d\n", result);  // gibt 3 aus (nicht 3.4)

Integer-Division schneidet Nachkommastellen ab.

Lösung:

if (x >= 1 && x <= 10) {
    printf("Gültig\n");
}

Häufige Fehler: || statt &&, oder 1 <= x <= 10 (syntaktisch gültig, aber semantisch falsch)

Lösung:

int max(int a, int b) {
    if (a > b) {
        return a;
    }
    return b;
}

// oder mit ternärem Operator:
int max(int a, int b) {
    return (a > b) ? a : b;
}

Lösung:

// Mit cs50.h:
int n = get_int("Zahl: ");
printf("%d\n", n * 2);

// Alternativ mit scanf (ohne cs50.h):
int n;
scanf("%d", &n);
printf("%d\n", n * 2);

Beide Varianten sind korrekt. Mit scanf muss man &n übergeben (Adresse der Variable).

Lösung:

// Variante 1: Schrittweite 2
for (int i = 2; i <= 20; i += 2) {
    printf("%d\n", i);
}

// Variante 2: Multiplikation
for (int i = 1; i <= 10; i++) {
    printf("%d\n", i * 2);
}

// Variante 3: Mit Modulo
for (int i = 1; i <= 20; i++) {
    if (i % 2 == 0) {
        printf("%d\n", i);
    }
}

Alle drei Varianten sind korrekt. Die Modulo-Variante prüft mit i % 2 == 0, ob eine Zahl gerade ist (Rest bei Division durch 2 ist 0).

Lösung:

int main(int argc, char *argv[]) {
    FILE *f = fopen(argv[1], "r");
    if (f == NULL) {
        return 1;  // Datei konnte nicht geöffnet werden
    }
    char line[1024];
    if (fgets(line, 1024, f) != NULL) {
        printf("%s", line);  // fgets behält \n, daher kein \n nötig
    }
    fclose(f);
}

Zu treffende Annahme: Die maximale Zeilenlänge muss angenommen werden. Im Beispiel sind es 1024 Zeichen - ein anderer Wert (z.B. 256, 512, 4096) wäre auch OK gewesen.

Alternative mit malloc (Heap statt Stack):

int main(int argc, char *argv[]) {
    FILE *f = fopen(argv[1], "r");
    if (f == NULL) {
        return 1;
    }
    char *line = malloc(1024);
    if (line == NULL) {
        fclose(f);
        return 1;
    }
    if (fgets(line, 1024, f) != NULL) {
        printf("%s", line);
    }
    free(line);
    fclose(f);
}

Guter Stil: Rückgabewerte von fopen, malloc und fgets auf NULL prüfen!

Hinweis: Dass man den Rückgabewert von fgets auf NULL prüfen sollte, haben wir in der Vorlesung bisher nicht behandelt. Wenn du das vergessen hast, kannst du trotzdem "Ja" ankreuzen.

Mögliche Fehler: fopen vergessen, falscher "mode", kein Buffer, fclose vergessen, argv[1] vergessen

Lösung:

Ausgabe: 4 - weil ptr + 3 auf das vierte Element zeigt (Index 3)

Äquivalent: numbers[3] oder ptr[3]

Lösung:

void increment(int *value) {
    (*value)++;
    // Alternativen für die Inkrementierung:
    // *value = *value + 1;
    // *value += 1;
}

int main(void) {
    int x = 5;
    increment(&x);
    printf("%d\n", x);  // 6
}

Häufiger Fehler: & beim Aufruf vergessen. Die Klammern bei (*value)++ sind wichtig - ohne sie würde der Pointer inkrementiert, nicht der Wert.

Lösung:

Ausgabe: x=7, y=10

Erklärung:

• *p = *q kopiert Wert von y nach x → x=7
• p = q biegt Pointer um, p zeigt jetzt auf y
• *p = 10 ändert y → y=10

Häufiger Fehler: Verwechslung von *p = *q (Wert kopieren) und p = q (Pointer umbiegen)

Lösung:

typedef struct {
    char name[50];
    int number;
} Person;

Person personen[3];
strcpy(personen[2].name, "Michaela");

// Ohne typedef (auch korrekt):
struct Person {
    char name[50];
    int number;
};
struct Person personen[3];
strcpy(personen[2].name, "Michaela");

// Alternative mit char* statt char[]:
typedef struct {
    char *name;
    int number;
} Person2;

Person2 personen2[3];
personen2[2].name = "Michaela";

Häufiger Fehler: personen[2].name = "Michaela" geht nicht bei char[] - man muss strcpy verwenden. Bei char* funktioniert die direkte Zuweisung.

Lösung:

int quadratsumme(int arr[], int n) {
    int sum = 0;
    for (int i = 0; i < n; i++) {
        sum += arr[i] * arr[i];
    }
    return sum;
}

int main(void) {
    int zahlen[] = {1, 2, 3, 4, 5};
    printf("%d\n", quadratsumme(zahlen, 5));  // 55
}

// Alternative mit Pointer-Syntax:
int quadratsumme(int *arr, int n) {
    int sum = 0;
    for (int i = 0; i < n; i++) {
        sum += arr[i] * arr[i];  // oder: *(arr+i) * *(arr+i)
    }
    return sum;
}

Wichtig: Die Länge n muss als Parameter übergeben werden, weil Arrays in C zu Pointern "zerfallen" (decay) - die Funktion kennt die Größe nicht. int arr[] und int *arr sind im Funktionsparameter gleichwertig.

Lösung:

1. Stack Buffer Overflow: buffer[5] ist zu klein für "Hello" - braucht 6 Bytes inkl. \0
2. Heap Buffer Overflow: malloc(5) ist ebenfalls zu klein für 6 Bytes
3. Use-After-Free: ptr zeigt auf copy[1], aber copy wurde mit free() freigegeben - Zugriff auf *ptr ist undefiniertes Verhalten (Dangling Pointer)

Hinweis: Das fehlende Testen des malloc-Rückgabewerts auf NULL ist prinzipiell auch ein Fehler (defensives Programmieren). Es ist hier aber nicht die Ursache dafür, dass sich das Programm nicht wie erwartet verhält - daher ist es egal, ob du diesen Fehler gefunden hast oder nicht.