C++ Arrays verstehen: Deklaration, Initialisierung und Pointer‑Techniken

Was ist ein Array?

In C++ ist ein Array ein Block fester Größe im zusammenhängenden Speicher, der Elemente desselben Datentyps hält. Man kann es sich als eine einzelne Variable vorstellen, die eine Sammlung von Werten repräsentiert, auf die über einen Index (beginnend bei 0) zugegriffen wird.

Arrays vereinfachen die Datenhaltung, indem sie zusammengehörige Werte gruppieren und effizientes Durchlaufen, direkten Zugriff und Massenoperationen ermöglichen.

Warum Arrays verwenden?

Arrays bieten:

• Kompakte Darstellung homogener Daten.
• Konstanten‑Zeit‑Indexzugriff (O(1)).
• Natürliche Eignung für Algorithmen, die sequentielle oder matrix‑artige Verarbeitung benötigen.

Array deklarieren

Syntax:

typ arrayName[arraySize];

• typ: Gültiger C++‑Datentyp (z. B. int, double, char).
• arrayName: Bezeichner für das Array.
• arraySize: Positive Ganzzahl für die Elementanzahl.

Beispiel: int age[5]; reserviert Platz für fünf Integer.

Array initialisieren

Werte können bei der Deklaration oder später gesetzt werden:

int age[5] = {19, 18, 21, 20, 17};

Wird arraySize weggelassen, ermittelt der Compiler die Größe automatisch:

int age[] = {19, 18, 21, 20, 17};

Einzelne Elemente lassen sich per Index zuweisen:

age[3] = 20; // 4. Element

Array‑Typen

• Eindimensional (1D)
• Mehrdimensional (2D, 3D, …)
• Zeiger auf Arrays

Eindimensionales Array

Lineare Speicherung:

int age[5] = {19, 18, 21, 20, 17};

Durchlauf‑Beispiel:

#include <iostream>
using namespace std;
int main() {
    int age[5] = {19, 18, 21, 20, 17};
    for (int i = 0; i < 5; ++i) {
        cout << age[i] << "\n";
    }
    return 0;
}

Ausgabe:

Zweidimensionales Array (Matrix)

Syntax: typ arrayName[zeilen][spalten];

int matrix[2][3] = {{0, 2, 1}, {4, 3, 7}};

Zugriff: matrix[zeile][spalte]. Durchlauf:

#include <iostream>
using namespace std;
int main() {
    int a[3][2] = {{0, 2}, {1, 4}, {3, 7}};
    for (int i = 0; i < 3; ++i) {
        for (int j = 0; j < 2; ++j) {
            cout << "a[" << i <<"] [" << j <<"] = " << a[i][j] << endl;
        }
    }
    return 0;
}

Ausgabe:

Dreidimensionales Array

Veranschaulicht einen Daten‑Würfel:

#include <iostream>
using namespace std;
int main() {
    int a[2][3][2] = { {{4, 8}, {2, 4}, {1, 6}}, {{3, 6}, {5, 4}, {9, 3}} };
    cout << "a[0][1][0] = " << a[0][1][0] << "\n";
    cout << "a[0][1][1] = " << a[0][1][1] << "\n";
    return 0;
}

Ausgabe:

Zeiger auf ein Array

Ein Arrayname zerfällt zu einem Zeiger auf sein erstes Element. Beispiel:

#include <iostream>
using namespace std;
int main() {
    int age[5] = {19, 18, 21, 20, 17};
    int *p = age; // p zeigt auf age[0]
    cout << "Adresse: " << p << "\n";
    cout << "Erster Wert: " << *p << "\n";
    return 0;
}

Zugriff per Zeigerarithmetik:

for (int i = 0; i < 5; ++i) {
    cout << "*(p + " << i <<") = " << *(p + i) << endl;
}

Elemente zugreifen

Der Index‑Operator [ ] wird verwendet:

int john = age[2]; // drittes Element

Vollständiges Beispiel:

#include <iostream>
using namespace std;
int main() {
    int age[5] = {19, 18, 21, 20, 17};
    int john = age[2];
    cout << "Das Alter von John ist: " << john;
    return 0;
}

Vorteile von Arrays in C++

• Schnelles sequenzielles Durchlaufen.
• O(1)‑Zufallszugriff.
• Geringer Speicher‑Overhead – keine dynamische Allokation nötig.
• Unterstützt algorithmische Optimierungen (z. B. cache‑freundliche Schleifen).
• Eingebaute Sprach‑ und Bibliotheksunterstützung.

Nachteile von Arrays in C++

• Feste Größe – nach Deklaration nicht mehr änderbar.
• Risiko von Out‑of‑Bounds‑Fehlern bei fehlerhafter Indexverwaltung.
• Speicherverschwendung, wenn deklarierte Größe die tatsächliche Nutzung übersteigt.
• Keine Laufzeit‑Grenzenprüfung bei Standard‑Arrays (verwenden Sie std::array oder std::vector für Sicherheit).

Zusammenfassung

• Ein Array ist ein zusammenhängender Speicherblock für Elemente eines Typs.
• Indizes beginnen bei 0; der letzte Index ist size‑1.
• Deklaration mit typ name[größe];, Initialisierung mit { } oder einzeln.
• 1D‑Arrays speichern linear; 2D‑ und 3D‑Arrays modellieren Matrizen und Tensoren.
• Zeiger auf Arrays ermöglichen flexibles Indizieren und Arithmetik.
• Arrays wählen, wenn Größe bekannt und Performance kritisch ist; sonst std::vector oder std::array bevorzugen.