Variablenlänge Arrays in C: Ein Leitfaden für Anfänger

Hallo da draußen, zukünftige Programmierer! Heute machen wir uns auf eine aufregende Reise in die Welt der Variablenlänge Arrays (VLAs) in C. Machen Sie sich keine Sorgen, wenn Sie neu im Programmieren sind – ich werde Ihr freundlicher Guide sein und alles Schritt für Schritt erklären. Also, tauchen wir ein!

Was sind Variablenlänge Arrays?

Bevor wir loslegen, lassen Sie uns verstehen, was Variablenlänge Arrays sind. Stellen Sie sich vor, Sie planen eine Party, aber Sie sind sich nicht sicher, wie viele Gäste kommen werden. Wär es nicht großartig, wenn Sie einen Tisch einrichten könnten, der seine Größe zauberhaft an die Anzahl der Gäste anpassen könnte? Genau das machen VLAs in der Programmierung!

Ein Variablenlänge Array ist ein Array, dessen Größe zur Laufzeit (wenn das Programm läuft) bestimmt wird,而不是在编译时 (wenn das Programm vorbereitet wird, um zu laufen). Diese Funktion wurde im C99-Standard eingeführt und bietet mehr Flexibilität bei der Array-Erstellung.

Erstellen eines Variablenlänge Arrays

Lassen Sie uns mit einem einfachen Beispiel beginnen, um ein VLA zu erstellen:

#include <stdio.h>

int main() {
int n;
printf("Wie viele Zahlen möchten Sie speichern? ");
scanf("%d", &n);

int numbers[n];  // Dies ist unser Variablenlänge Array

printf("Geben Sie %d Zahlen ein:\n", n);
for (int i = 0; i < n; i++) {
scanf("%d", &numbers[i]);
}

printf("Sie haben eingegeben: ");
for (int i = 0; i < n; i++) {
printf("%d ", numbers[i]);
}

return 0;
}

Lassen Sie uns das durcharbeiten:

1. Wir fragen den Benutzer, wie viele Zahlen er speichern möchte.
2. Wir erstellen ein Array numbers mit der Größe n, die der Benutzer eingegeben hat.
3. Wir verwenden eine Schleife, um n Zahlen vom Benutzer einzugeben.
4. Schließlich geben wir alle von dem Benutzer eingegebenen Zahlen aus.

Das ist die Schönheit der VLAs – wir mussten die Größe des Arrays nicht beim Schreiben des Codes wissen. Die Größe wird zur Laufzeit bestimmt!

Zweidimensionale Variablenlänge Arrays

Nun, lassen Sie uns eine Stufe höher gehen und uns zweidimensionale VLAs ansehen. Stellen Sie sich vor, Sie erstellen eine Sitzordnung für eine Hochzeit, aber Sie wissen nicht, wie viele Tische es geben wird oder wie viele Sitze jeder Tisch haben wird. Zweidimensionale VLAs können Ihnen helfen!

Hier ist ein Beispiel:

#include <stdio.h>

int main() {
int tables, seats;

printf("Wie viele Tische? ");
scanf("%d", &tables);

printf("Wie viele Sitze pro Tisch? ");
scanf("%d", &seats);

int seating[tables][seats];  // Unser 2D Variablenlänge Array

// Zuweisen von Sitznummern
for (int i = 0; i < tables; i++) {
for (int j = 0; j < seats; j++) {
seating[i][j] = i * seats + j + 1;
}
}

// Ausgabe der Sitzordnung
printf("\nSitzordnung:\n");
for (int i = 0; i < tables; i++) {
printf("Tisch %d: ", i + 1);
for (int j = 0; j < seats; j++) {
printf("%3d ", seating[i][j]);
}
printf("\n");
}

return 0;
}

In diesem Beispiel:

1. Wir fragen den Benutzer nach der Anzahl der Tische und Sitze pro Tisch.
2. Wir erstellen ein 2D VLA seating mit den Dimensionen [tables][seats].
3. Wir weisen Sitznummern zu jeder Position zu.
4. Schließlich geben wir die Sitzordnung aus.

Diese Flexibilität ermöglicht es uns, eine Sitzordnung jeder Größe zu erstellen, die zur Laufzeit bestimmt wird!

Geraffelte Arrays

Nun, hier wird es wirklich interessant. Was ist, wenn jeder Tisch bei unserer Hochzeit eine andere Anzahl von Sitzen hat? Hier kommt das geraffelte Array ins Spiel – ein Array von Arrays, bei dem jedes Unterarray eine andere Länge haben kann.

Während C keine geraffelten Arrays wie einige andere Sprachen direkt unterstützt, können wir sie mit VLAs und Zeigern simulieren. Hier ist, wie:

#include <stdio.h>
#include <stdlib.h>

int main() {
int tables;
printf("Wie viele Tische? ");
scanf("%d", &tables);

int *seats = malloc(tables * sizeof(int));
int **seating = malloc(tables * sizeof(int*));

// Eingabe der Anzahl der Sitze für jeden Tisch
for (int i = 0; i < tables; i++) {
printf("Wie viele Sitze am Tisch %d? ", i + 1);
scanf("%d", &seats[i]);
seating[i] = malloc(seats[i] * sizeof(int));
}

// Zuweisen von Sitznummern
for (int i = 0; i < tables; i++) {
for (int j = 0; j < seats[i]; j++) {
seating[i][j] = j + 1;
}
}

// Ausgabe der Sitzordnung
printf("\nSitzordnung:\n");
for (int i = 0; i < tables; i++) {
printf("Tisch %d: ", i + 1);
for (int j = 0; j < seats[i]; j++) {
printf("%3d ", seating[i][j]);
}
printf("\n");
}

// Freigeben des zugewiesenen Speichers
for (int i = 0; i < tables; i++) {
free(seating[i]);
}
free(seating);
free(seats);

return 0;
}

Dieses Beispiel ist komplexer, daher lassen Sie uns das durcharbeiten:

1. Wir erstellen ein Array seats, um die Anzahl der Sitze für jeden Tisch zu speichern.
2. Wir erstellen einen Zeiger auf Zeiger seating, um unser geraffeltes Array zu simulieren.
3. Wir allokieren dynamisch Speicher für jeden Tisch basierend auf seiner Anzahl von Sitzen.
4. Wir weisen Sitznummern zu und geben die Anordnung aus, wie zuvor.
5. Schließlich geben wir den zugewiesenen Speicher frei, um Speicherlecks zu vermeiden.

Diese Methode ermöglicht es uns, für jeden Tisch eine andere Anzahl von Sitzen zu haben – wirklich flexibel!

Methodenübersicht

Hier ist eine kurze Referenztabelle der Methoden, die wir in unseren Beispielen verwendet haben:

Methode	Beschreibung	Beispiel
scanf()	Liest formatierte Eingaben vom Benutzer	scanf("%d", &n);
printf()	Gibt formatierte Ausgaben in die Konsole aus	printf("Hallo, %s!", name);
malloc()	Allokiert Speicher dynamisch	int *arr = malloc(n * sizeof(int));
free()	Gibt dynamisch zugewiesenen Speicher frei	free(arr);

Erinnern Sie sich daran, mit großer Macht kommt große Verantwortung. VLAs und dynamische Speicher allocation sind mächtige Werkzeuge, aber sie müssen sorgfältig eingesetzt werden, um Probleme wie Stack-Überschreitung oder Speicherlecks zu vermeiden.

Und das war's! Sie haben gerade Ihre ersten Schritte in die Welt der Variablenlänge Arrays in C unternommen. Erinnern Sie sich daran, Übung macht den Meister, also fürchten Sie sich nicht, mit diesen Konzepten zu experimentieren. Frohes Programmieren!

Credits: Image by storyset