C Array length bestimmen: Die besten Methoden

Durch den Einsatz ver­schie­de­ner Methoden können Sie die Länge von Arrays in C ermitteln. Dadurch wird es einfacher, Arrays dynamisch zu verwalten und auf Än­de­run­gen in der Größe zu reagieren.

C Array Length

Die Länge eines C Arrays be­zeich­net die Anzahl der Elemente, die es enthält. Diese In­for­ma­ti­on ist ent­schei­dend, um auf bestimmte Elemente im Array zu­zu­grei­fen, es zu durch­lau­fen oder Ma­ni­pu­la­tio­nen vor­zu­neh­men. Wenn Sie ein Array in C de­kla­rie­ren, wird der Speicher für die Elemente des Arrays kon­ti­nu­ier­lich im RAM alloziert. In C gibt es keine direkte ein­ge­bau­te Funktion zur Er­mitt­lung der Array-Länge, daher müssen Sie diese manuell ermitteln.

Zu den häu­figs­ten Methoden zählen:

• sizeof()
• Pointer-Arith­me­tik
• Schleifen

sizeof()

sizeof()gehört zu den C-Ope­ra­to­ren in der Pro­gram­mier­spra­che C. Es ermittelt die Größe eines Datentyps oder einer Variable in Bytes während der Über­set­zungs­zeit (Compile-Zeit). Der Rück­ga­be­typ des sizeof-Operators ist size_t, ein vor­zei­chen­lo­ser ganz­zah­li­ger Typ, der die Größe in Bytes re­prä­sen­tiert. Mit der sizeof()-Funktion in C können Sie auch die C Array Length berechnen.

Syntax

Um die Anzahl der Elemente zu bestimmen, müssen Sie die Ge­samt­grö­ße des Arrays durch die Größe eines einzelnen Elements teilen.

data_type arrayLength = sizeof(array_name) / sizeof(array_name[index]);

• data_type: Das ist der Datentyp, in welchem die Länge des Arrays ge­spei­chert werden soll.
• array_name: Gibt den Namen des Arrays an.
• sizeof(array_name): Diese Aus­drucks­an­wei­sung gibt die Ge­samt­grö­ße des Arrays in Bytes zurück.
• sizeof(array_name[index]): Durch die Division der Ge­samt­grö­ße des Arrays durch die Größe eines einzelnen Elements erhalten Sie die Anzahl der Elemente im Array.
• index: Dies steht für den Index eines Elements im Array.

Beispiel

Nach­fol­gend ermitteln wir mit sizeof() die Größe des Arrays myArray und eines einzelnen Elements in Bytes, wodurch wir im Anschluss die Anzahl der Elemente durch Division der Er­geb­nis­se berechnen können.

int main() {
    int myArray[] = {1, 2, 3, 4, 5};
    size_t totalSize = sizeof(myArray);
    size_t elementSize = sizeof(myArray[0]);
    size_t arrayLength = totalSize / elementSize;
    printf("Total size of the array: %d bytes\n", (int)totalSize);
    printf("Size of a single element: %d bytes\n", (int)elementSize);
    printf("Number of elements in the array: %d\n", (int)arrayLength);
    return 0;
}

Die Ausgabe lautet:

Total size of the array: 20 bytes
Size of a single element: 4 bytes
Number of elements in the array: 5

Pointer-Arith­me­tik

Mit Pointer-Arith­me­tik ist die Länge eines Arrays nicht direkt be­stimm­bar, da ein Pointer allein keine In­for­ma­ti­on über die Größe oder Länge des zu­ge­hö­ri­gen Arrays enthält. Aber Sie können die Adressen von Array-Elementen nutzen, um die C Array Length zu ermitteln.

Syntax

data_type arr_length = *(&arr + 1) - arr;

• &arr: Dies stellt einen Zeiger auf ein Array von Elementen dar.
• (&arr + 1): Hier wird der Zeiger auf das Array arr um 1 erhöht. Da arr ein Array ist, bedeutet dies, dass der Zeiger auf das nächste auf­ein­an­der­fol­gen­de Array vom gleichen Typ wie arr zeigt.

Beispiel

Der Ausdruck *(&arr + 1) - arr berechnet die Differenz zwischen dem Zeiger auf das nächste Array &arr + 1 und dem Zeiger auf das erste Element des ur­sprüng­li­chen Arrays. In diesem Fall ist der „nächste“ Spei­cher­be­reich das Ende des Arrays. Die re­sul­tie­ren­de Differenz ist gleich der Anzahl der Elemente im Array.

#include <stdio.h>
int main() {
    int arr[] = {1, 2, 3, 4, 5};
    int length = *(&arr + 1) - arr;
    printf("Number of elements in the array: %d\n", length);
    return 0;
}

Ausgabe:

Number of elements in the array: 5

Schleifen

Eine weitere Methode ist das Bestimmen der C Array Length mit einer for-Schleife. Diese iteriert durch das Array und zählt, wie viele Elemente es enthält. Dazu muss das Array im gleichen Gül­tig­keits­be­reich (Scope) de­kla­riert sein, in dem der Code zur Län­gen­be­stim­mung aus­ge­führt wird.

Beispiel

Hier erhöht die Schleife den Zähler arrayLength für jedes durch­lau­fe­ne Element. Die Bedingung i < sizeof(arr) / sizeof(arr[0]) stellt sicher, dass die Schleife nur so lange läuft, wie es tat­säch­lich Elemente im Array gibt.

#include <stdio.h>
int main() {
    int arr[] = {1, 2, 3, 4, 5, 6, 7, 8};
    size_t arrayLength = 0;
    for (size_t i = 0; i < sizeof(arr) / sizeof(arr[0]); ++i) {
        arrayLength++;
    }
    printf("Number of elements in the array: %d\n", arrayLength);
    return 0;
}

Ausgabe:

Number of elements in the array: 8