Mit Arrays können Sie in C einen Satz von zu­ein­an­der ge­hö­ren­den Daten speichern, ohne mehrere Variablen anlegen zu müssen. In der Regel sind Arrays ein­di­men­sio­nal, lassen sich jedoch um beliebig viele Di­men­sio­nen erweitern. Wir zeigen Ihnen, wie Sie 2D Arrays in C anlegen und effektiv nutzen können.

Grund­le­gen­des zu Arrays in C

Um 2D Arrays in C effektiv anlegen und be­herr­schen zu können, sollte man zuerst einige grund­le­gen­de Dinge über Arrays in der Pro­gram­mier­spra­che C wissen. Wie in vielen anderen Sprachen handelt es sich bei Arrays um einen Spei­cher­block, in dem mehrere Werte desselben Datentyps ge­spei­chert werden können. So lassen sich mehrere Werte unter einem Va­ria­blen­na­men speichern und zu­sam­men­fas­sen. Die Größe des Arrays muss zur Kom­pi­lier­zeit bekannt sein und kann nicht nach­träg­lich geändert werden. Folgender Codeblock zeigt, wie man Arrays in C anlegt:

int zahlen1[15];
// Optional können die gespeicherten Werte schon beim Anlegen angegeben werden:
int zahlen2[5] = {1, 2, 3, 4, 5};
c

In diesem Beispiel wird der Typ der zu spei­chern­den Daten wie gewohnt vor dem Va­ria­blen­na­men angegeben. Die eckigen Klammern sagen aus, dass es sich bei dieser Variable nicht um einen einzelnen Wert, sondern um ein Array handelt. Die Ganzzahl zwischen den Klammern gibt an, wie viele Elemente dieses Datentyps im Array ge­spei­chert werden können. Das Array zahlen1 wird im obigen Beispiel un­in­itia­li­siert angelegt – das heißt, dass keine Werte in den Feldern ge­schrie­ben werden. Diese können dann später im Code mit Werten befüllt werden.

Das Array zahlen2 wird da­hin­ge­gen schon beim Anlegen manuell in­itia­li­siert. Dieser Ansatz ist in den meisten Fällen nicht zu empfehlen, da er bei größeren Arrays sehr aufwendig und der daraus ent­ste­hen­de Code oft nicht leserlich ist. Versuchen Sie also lieber, Ihre Arrays pro­gram­ma­tisch zu befüllen, zum Beispiel mit einer For-Schleife:

zahlen2[100];
for(int i = 0; i < 100; i++) {
zahlen2[i] = i + 1;
}
// Erzeugt ein Array, das die Ganzzahlen 1 bis 100 enthält.
c
Hinweis

Je nachdem, auf welchem Be­triebs­sys­tem Sie arbeiten, welchen C-Standard Sie nutzen und wo in Ihrem Programm Sie eine un­in­itia­li­sier­te Variable de­kla­riert haben, kann in dieser Variable ein zu­fäl­li­ger Wert stehen. Dies gilt auch für Array-Felder. Greifen Sie also am besten nicht auf Felder zu, die Sie noch nicht in­itia­li­siert haben, vor allem wenn der darin ge­spei­cher­te Wert als Pointer in­ter­pre­tiert werden soll.

Nachdem ein Array angelegt wurde, kann mit dem Index auf in­di­vi­du­el­le Werte zu­ge­grif­fen werden. Beachten Sie, dass Arrays mit dem Index 0 anfangen. Folgendes Beispiel dient zur Ver­an­schau­li­chung:

int zahlen2[5] = {1, 2, 3, 4, 5};
zahlen2[3] = zahlen2[2];
printf("%d\n", zahlen2[3]);
// Ausgabe: 3
c

Ein 2D Array lässt sich in C rea­li­sie­ren, indem man ein Array anlegt, worin jedes Feld ein weiteres Array enthält. Lesen Sie weiter, um Genaueres zu erfahren.

2D Array in C: So wird’s gemacht

2D Arrays in C sind nichts anderes als ein­di­men­sio­na­le Arrays, deren Felder jeweils ein weiteres Array enthalten. Ein 2D Array kann man also als Tabelle oder Matrix von Werten verstehen. 2D Arrays lassen sich mit folgender Syntax anlegen und befüllen:

2d_ints[10][10];
2d_ints[0][1] = 0;
2d_ints[2][1] = 2;
2d_ints[9][4] = 36;
// usw.
c

Hier stellt die Zahl in den linken eckigen Klammern den Index im ersten Array dar, auf das zu­ge­grif­fen werden soll, und die rechte den Index im zweiten. Diese beiden Zahlen kann man sich als 2D-Ko­or­di­na­ten oder Reihen- bzw. Spal­ten­num­mer vor­stel­len. Wie ein­di­men­sio­na­le Arrays lassen sich zwei­di­men­sio­na­le Arrays auch schon beim Anlegen mit Werten in­itia­li­sie­ren.

2d_floats[2][6] = {
{0.1, 3.56, 6.346, 8.9, 45.345, 2.284}
{7.0, 1.12, 9.74, 0.0, 3.56, 4.4}
}
c

Das Prinzip eines Arrays innerhalb eines anderen Arrays ist nicht auf zwei Di­men­sio­nen be­schränkt. Mit dieser Methode können Sie Arrays mit beliebig vielen Di­men­sio­nen anlegen.

int 4d_ints[10][10][10][10]
c
Web­hos­ting
Das beste Web­hos­ting zum Spit­zen­preis
  • 3x schneller und 60 % günstiger
  • Maximale Ver­füg­bar­keit mit > 99.99 %
  • Nur bei IONOS: Bis zu 500 GB Spei­cher­platz inklusive

An­wen­dungs­fäl­le von 2D Arrays in C

Über ein 2D Array iterieren

Der häufigste An­wen­dungs­fall von 2D Arrays in C (bzw. mehr­di­men­sio­na­ler Arrays) ist das Anlegen mehr­di­men­sio­na­ler Da­ten­struk­tu­ren. In folgendem Beispiel wird ein zwei­di­men­sio­na­ler Array ab­wech­selnd mit Nullen und Einsen befüllt, um ein Schach­brett dar­zu­stel­len:

#include <stdio.h>
#define ARRAY_LENGTH 8
int main() {
    int schachbrett[8][8];
    for(int i = 0; i < ARRAY_LENGTH; i++) {
        for(int j = 0; j < ARRAY_LENGTH; j++) {
            schachbrett[i][j] = (i + j) % 2;
            printf("%d", schachbrett[i][j]);
        }
        printf("\n");
    }
    return 0;
}
/*
Ausgabe:
01010101
10101010
01010101
10101010
01010101
10101010
01010101
10101010
*/
c

Ein Array von Strings

Ein Detail, das für den ge­schick­ten Einsatz von Arrays sehr wichtig ist: Ein Array ist ei­gent­lich nur ein Pointer auf eine Stelle im Speicher und wird vom C-Compiler auch so ver­stan­den. Der Index, der beim Be­schrei­ben bzw. Auslesen in­di­vi­du­el­ler Felder angegeben wird, stellt also die Ver­schie­bung entlang des Arrays relativ zur Ba­sis­adres­se dar. Folgendes Beispiel soll dies ver­deut­li­chen:

int zahlen2[5] = {1, 2, 3, 4, 5};
printf("%d\n", *zahlen2);
// Ausgabe: 1
printf("%d\n", *(zahlen2 + 2));
// Ausgabe: 3
c

Strings werden in C auf gleiche Weise behandelt. So ist es also möglich, über einen String zu iterieren, als wäre er ein Array. Dies ist in folgendem Beispiel zu sehen, in dem drei in einem Array ge­spei­cher­te Sätze Zeichen für Zeichen in Groß­buch­sta­ben aus­ge­ge­ben werden. Um auf Zeichen zu­zu­grei­fen, wird das Array-Indexfeld (eckige Klammern) verwendet:

#include <stdio.h>
int main() {
    char* saetze[3];
    saetze[0] = "Hallo, dies ist der erste Satz.\n";
    saetze[1] = "Dies ist nur der zweite Satz.\n";
    saetze[2] = "Und jetzt sind es drei.\n";
    printf("Originale Sätze:\n\n");
    for(int i = 0; i < 3; i++) {
        printf("%s", saetze[i]);
    }
    printf("\nVeränderte Sätze:\n\n");
    for(int i = 0; i < 3; i++) {
        int j = 0;
        while(saetze[i][j] != '\n') {
            if(saetze[i][j] >= 'a' && saetze[i][j] <= 'z') {
                printf("%c", saetze[i][j] - 0x20);
            } else {
                printf("%c", saetze[i][j]);
            }
            j++;
        }
        printf("\n");
    }
}
/*
Ausgabe:
Originale Sätze:
Hallo, dies ist der erste Satz.
Dies ist nur der zweite Satz.
Und jetzt sind es drei.
Veränderte Sätze:
HALLO, DIES IST DER ERSTE SATZ.
DIES IST NUR DER ZWEITE SATZ.
UND JETZT SIND ES DREI.
*/
c
Zum Hauptmenü