Aufgabe 1 – Dynamisches Array anlegen und ausgeben

Schreibe ein Programm, das:

  • mit malloc ein Integer-Array der Größe 5 reserviert,
  • die Werte 1, 2, 3, 4, 5 speichert,
  • alle Werte ausgibt,
  • den Speicher korrekt freigibt.
Musterlösung: Dynamisches Array anlegen und ausgeben 
#include <stdio.h>
#include <stdlib.h>

int main() {
    int *arr = malloc(5 * sizeof(int));
    if (!arr) return 1;

    for (int i = 0; i < 5; i++) {
        arr[i] = i + 1;
    }

    for (int i = 0; i < 5; i++) {
        printf("%d ", arr[i]);
    }

    free(arr);
    return 0;
}

Aufgabe 2 – Dynamische Initialisierung mit Benutzereingabe

Lies die gewünschte Arraygröße vom Benutzer ein, reserviere dynamisch Speicher und initialisiere das Array mit fortlaufenden Zahlen ab 10.

Musterlösung: Dynamische Initialisierung mit Benutzereingabe 
#include <stdio.h>
#include <stdlib.h>

int main() {
    int n;
    printf("Arraygröße: ");
    scanf("%d", &n);

    int *arr = malloc(n * sizeof(int));
    if (!arr) return 1;

    for (int i = 0; i < n; i++) {
        arr[i] = 10 + i;
    }

    for (int i = 0; i < n; i++) {
        printf("%d ", arr[i]);
    }

    free(arr);
    return 0;
}

Aufgabe 3 – Summe eines dynamischen Arrays

Implementiere ein Programm, das:

  • ein dynamisches Array erstellt,
  • die Werte vom Benutzer einliest,
  • die Summe aller Elemente berechnet.
Musterlösung: Summe eines dynamischen Arrays 
#include <stdio.h>
#include <stdlib.h>

int main() {
    int n, sum = 0;
    scanf("%d", &n);

    int *arr = malloc(n * sizeof(int));
    if (!arr) return 1;

    for (int i = 0; i < n; i++) {
        scanf("%d", &arr[i]);
        sum += arr[i];
    }

    printf("Summe: %d\n", sum);
    free(arr);
    return 0;
}

Aufgabe 4 – Array mit realloc vergrößern

Erweitere ein dynamisches Array von Größe 3 auf Größe 6 mit realloc und initialisiere die neuen Elemente sinnvoll. Beachte, dass Du zunächst ein Array mit Hilfe von malloc anlegst, bevor Du es dann mit realloc vergrößerst.

Musterlösung: Array mit realloc vergrößern 
#include <stdio.h>
#include <stdlib.h>

int main() {
    int n = 3;
    int *arr = malloc(n * sizeof(int));
    if (!arr) return 1;

    for (int i = 0; i < n; i++)
        arr[i] = (i + 1) * 10;

    n = 6;
    arr = realloc(arr, n * sizeof(int));
    if (!arr) return 1;

    for (int i = 3; i < n; i++)
        arr[i] = (i + 1) * 10;

    for (int i = 0; i < n; i++)
        printf("%d ", arr[i]);

    free(arr);
    return 0;
}

Aufgabe 5 – Array verkleinern

Erstelle ein dynamisches Array mit 6 Elementen und verkleinere es anschließend auf 3 Elemente mit realloc. Was passiert mit den Elementen, die der Verkleinerung zum Opfer fallen?

Musterlösung: Array verkleinern 
#include <stdio.h>
#include <stdlib.h>

int main() {
    int *arr = malloc(6 * sizeof(int));
    if (!arr) return 1;

    for (int i = 0; i < 6; i++)
        arr[i] = i + 1;

    arr = realloc(arr, 3 * sizeof(int));
    if (!arr) return 1;

    for (int i = 0; i < 3; i++)
        printf("%d ", arr[i]);

    free(arr);
    return 0;
}

Aufgabe 6 – Dynamisches Array in Funktion erstellen

Schreibe eine Funktion, die:

  • ein dynamisches Array erstellt,
  • es initialisiert,
  • den Pointer zurückgibt.
Musterlösung: Dynamisches Array in Funktion erstellen 
#include <stdio.h>
#include <stdlib.h>

int* createArray(int n) {
    int *arr = malloc(n * sizeof(int));
    if (!arr) return NULL;

    for (int i = 0; i < n; i++)
        arr[i] = i * 2;

    return arr;
}

int main() {
    int *arr = createArray(5);
    if (!arr) return 1;

    for (int i = 0; i < 5; i++)
        printf("%d ", arr[i]);

    free(arr);
    return 0;
}

Aufgabe 7 – Dynamisches Array in Funktion vergrößern

Schreibe eine Funktion, die ein bestehendes Array mit realloc vergrößert.

Musterlösung: Dynamisches Array in Funktion vergrößern 
#include <stdio.h>
#include <stdlib.h>

int* resizeArray(int *arr, int newSize) {
    return realloc(arr, newSize * sizeof(int));
}

int main() {
    int *arr = malloc(3 * sizeof(int));
    if (!arr) return 1;

    for (int i = 0; i < 3; i++)
        arr[i] = i + 1;

    arr = resizeArray(arr, 6);
    if (!arr) return 1;

    for (int i = 3; i < 6; i++)
        arr[i] = i + 1;

    for (int i = 0; i < 6; i++)
        printf("%d ", arr[i]);

    free(arr);
    return 0;
}

Aufgabe 8 – Sicheres realloc mit temporärem Pointer

Verwende einen temporären Pointer, um Speicherverlust bei fehlgeschlagenem realloc zu vermeiden.

Musterlösung: Sicheres realloc mit temporärem Pointer 
#include <stdio.h>
#include <stdlib.h>

int main() {
    int *arr = malloc(3 * sizeof(int));
    if (!arr) return 1;

    int *tmp = realloc(arr, 6 * sizeof(int));
    if (!tmp) {
        free(arr);
        return 1;
    }
    arr = tmp;

    free(arr);
    return 0;
}

Aufgabe 9 – Dynamisches Wachstum während Laufzeit

Lies Zahlen vom Nutzer ein und speichere sie in ein Array. Der Nutzer soll beliebig viele Zahlen eingeben können. Wenn der Benutzer -1 eingibt, dann soll das Eingeben beendet werden. Das Array soll dabei dynamisch wachsen, sodass immer genügend Speicher für das Speichern der Nutzereingaben zur Verfügung steht.

Musterlösung: Dynamisches Wachstum während Laufzeit 
#include <stdio.h>
#include <stdlib.h>

int main() {
    int *arr = NULL;
    int size = 0, value;

    while (1) {
        scanf("%d", &value);
        if (value == -1) break;

        int *tmp = realloc(arr, (size + 1) * sizeof(int));
        if (!tmp) {
            free(arr);
            return 1;
        }
        arr = tmp;
        arr[size++] = value;
    }

    for (int i = 0; i < size; i++)
        printf("%d ", arr[i]);

    free(arr);
    return 0;
}

Aufgabe 10 – Dynamisches Array mit Fehlerrobustheit

Schreibe ein Programm, das:

  • dynamisch Speicher verwaltet,
  • alle Speicherfehler abfängt,
  • garantiert keinen Speicher leak erzeugt.
Musterlösung: Dynamisches Array mit Fehlerrobustheit 
#include <stdio.h>
#include <stdlib.h>

int main() {
    int *arr = malloc(5 * sizeof(int));
    if (!arr) {
        fprintf(stderr, "malloc fehlgeschlagen\n");
        return 1;
    }

    int *tmp = realloc(arr, 10 * sizeof(int));
    if (!tmp) {
        fprintf(stderr, "realloc fehlgeschlagen\n");
        free(arr);
        return 1;
    }

    arr = tmp;
    free(arr);
    return 0;
}
Nach oben scrollen