Arrays in C ++ - Deklarieren - Initialisieren - Zeiger auf Array-Beispiele

Was ist ein Array?

Ein Array ist eine Datenstruktur, in der ein Element desselben Datentyps nacheinander gespeichert wird. Ein C ++ - Array hat eine feste Größe.

Sie können ein Array als Sammlung von Variablen eines ähnlichen Datentyps anzeigen. Anstatt jede Variable zu deklarieren und ihr einzeln einen Wert zuzuweisen, können Sie eine Variable (das Array) deklarieren und die Werte der verschiedenen Variablen hinzufügen. Jeder Mehrwert des Arrays wird durch einen Index identifiziert.

In diesem C ++ - Tutorial lernen Sie:

• Was ist ein Array?
• Warum brauchen wir Arrays?
• Deklarieren Sie ein Array in C ++
• Array-Initialisierung
• Arten von Arrays
• Eindimensionales Array
• Mehrdimensionales Array
• Zweidimensionales Array
• Dreidimensionales Array
• Zeiger auf ein Array
• Zugriff auf die Werte eines Arrays
• Vorteile eines Arrays in C ++
• Nachteile eines Arrays in C ++

Warum brauchen wir Arrays?

Arrays sind in jeder Programmiersprache sehr wichtig. Sie bieten eine bequemere Möglichkeit, Variablen oder eine Sammlung von Daten eines ähnlichen Datentyps zusammen zu speichern, anstatt sie separat zu speichern. Auf jeden Wert des Arrays wird separat zugegriffen.

Deklarieren Sie ein Array in C ++

Bei der Array-Deklaration in C ++ werden der Typ sowie die Anzahl der vom Array zu speichernden Elemente angegeben. Syntax:

type array-Name [ array-Size ];

Regeln zum Deklarieren eines eindimensionalen Arrays in C ++.

• Typ: Der Typ ist der Typ der Elemente, die im Array gespeichert werden sollen, und muss ein gültiger C ++ - Datentyp sein.
• Array-Name: Der Array-Name ist der Name, der dem Array zugewiesen werden soll.
• Array-Größe: Die Array-Größe ist die Anzahl der Elemente, die im Array gespeichert werden sollen. Es muss eine ganze Zahl und größer als 0 sein.

Sie können beispielsweise ein Array mit dem Namen age erstellen und das Alter von 5 Schülern wie folgt speichern:

int age[5];

Das Array-Alter speichert 5 Ganzzahlen, die das Alter verschiedener Schüler darstellen.

Array-Initialisierung

Bei der Array-Initialisierung werden einem Array Elemente zugewiesen / gespeichert. Die Initialisierung kann in einer einzelnen Anweisung oder einzeln erfolgen. Beachten Sie, dass das erste Element in einem Array im Index 0 gespeichert ist, während das letzte Element im Index n-1 gespeichert ist, wobei n die Gesamtzahl der Elemente im Array ist.

Im Fall des Altersarrays wird das erste Element bei Index 0 gespeichert, während das letzte Element bei Index 4 gespeichert wird.

Lassen Sie uns das Altersarray verwenden, um zu demonstrieren, wie die Array-Initialisierung durchgeführt werden kann:

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

Die Gesamtzahl der Elemente in {} darf den in [] angegebenen Wert nicht überschreiten. Das Element 19 befindet sich am Index 0, 18 am Index 1, 21 am Index 2, 20 am Index 3 und 17 am Index 4. Wenn Sie nicht die Anzahl der Elemente angeben, die im Array innerhalb von [] gespeichert werden sollen, das Array wird nur groß genug sein, um die in {} hinzugefügten Elemente aufzunehmen. Zum Beispiel:

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

Die obige Anweisung erstellt genau das gleiche Array wie die vorherige. Sie können einem Array auch ein Element mithilfe seines Index zuweisen. Zum Beispiel:

age[3] = 20;

Die obige Anweisung speichert den Wert 20 im Index 3 des Arrays mit dem Namen age. Dies bedeutet , dass 20 das 4 seine ^ten Element des Arrays.

Arten von Arrays

Es gibt zwei Arten von C ++ - Arrays:

• Eindimensionales Array
• Mehrdimensionales Array
• Zeiger auf ein Array

Eindimensionales Array

Dies ist ein Array, in dem die Datenelemente nur in einer Dimension linear angeordnet sind. Es wird allgemein als 1-D-Array bezeichnet. Syntax:

datatype array-name[size];

• Der Array-Name ist der Name des Arrays.
• Die Größe ist die Anzahl der Elemente, die im Array gespeichert werden sollen.

Zum Beispiel:

#include using namespace std;int main(){int age[5] = { 19, 18, 21, 20, 17 };for (int x = 0; x < 5; x++){cout <
Ausgabe:

Hier ist ein Screenshot des Codes:

Code Erläuterung:

Aufnahme der iostream-Header-Datei in unseren Code. Dadurch können wir von der Konsole lesen und darauf schreiben.
Einschließen des Standard-Namespace, um seine Klassen und Funktionen zu verwenden, ohne ihn aufzurufen.
Aufruf der main () -Funktion, in der die Logik des Programms hinzugefügt werden soll.
Beginn des Hauptteils der Funktion main ().
Deklarieren eines Arrays mit dem Namen age zum Speichern von 5 Ganzzahlen. Die 5 Ganzzahlen wurden ebenfalls initialisiert.
Erstellen Sie eine Ganzzahlvariable x mit einer for-Schleife.
Der Anfang des Körpers der for-Schleife.
Verwenden Sie die Schleifenvariable x, um die Werte des Array-Alters zu durchlaufen und auf der Konsole zu drucken. Das "\ n" ist ein Zeilenumbruchzeichen und wird nach jeder Iteration in einer neuen Zeile gedruckt.
Ende des Körpers der for-Schleife.
Ende des Körpers der main () - Funktion.

Mehrdimensionales Array
Dies ist ein Array, in dem Datenelemente angeordnet sind, um ein Array von Arrays zu bilden. Ein mehrdimensionales Array kann eine beliebige Anzahl von Dimensionen haben, jedoch sind zweidimensionale und dreidimensionale Arrays üblich. Syntax:


datatype array-name[d1][d2][d3]… [dn];
Der Array-Name ist der Name des Arrays mit n Dimensionen. Zum Beispiel:
Zweidimensionales Array
Ein 2D-Array speichert Daten in einer Liste mit einem 1-D-Array. Es ist eine Matrix mit Zeilen und Spalten. Verwenden Sie die folgende Syntax, um ein 2D-Array zu deklarieren:
type array-Name [ x ][ y ];
Der Typ muss ein gültiger C ++ - Datentyp sein. Sehen Sie sich ein 2D-Array als Tabelle an, wobei x die Anzahl der Zeilen und y die Anzahl der Spalten angibt. Dies bedeutet, dass Sie jedes Element in einem 2D-Array mit der Form a [x] [y] identifizieren, wobei x die Anzahl der Zeilen und y die Anzahl der Spalten ist, zu denen das Element gehört.
Hier ist ein Beispiel für die Initialisierung eines 2D-Arrays:
int a[2][3] = {{0, 2, 1} , /* row at index 0 */{4, 3, 7} , /* row at index 1 */};
Im obigen Beispiel haben wir ein 2D-Array, das als 2x3-Matrix angesehen werden kann. Es gibt 2 Zeilen und 3 Spalten. Auf das Element 0 kann als [0] [1] zugegriffen werden, da es sich am Schnittpunkt von Zeile indiziert 0 und Spalte indiziert 1 befindet. Auf das Element 3 kann als [1] [2] zugegriffen werden, da es sich am befindet Schnittpunkt von Zeile 1 und Spalte 2.
Beachten Sie, dass wir einfach geschweifte Klammern hinzugefügt haben, um die verschiedenen Elementreihen zu unterscheiden. Die Initialisierung hätte auch wie folgt erfolgen können:
int a[2][3] = {0, 2, 1, 4, 3, 7};};
Das folgende C ++ - Beispiel zeigt, wie ein 2D-Array initialisiert und durchlaufen wird:
#include using namespace std;int main(){// a 2x3 arrayint a[3][2] = { {0, 2}, {1, 4}, {3, 7} };// traverse array elementsfor (int i=0; i<3; i++)for (int j=0; j<2; j++){cout << "a[" <
Ausgabe:

Hier ist ein Screenshot des obigen Codes:

Code Erläuterung:

Aufnahme der iostream-Header-Datei in unseren Code. Dadurch können wir von der Konsole lesen und darauf schreiben.
Einschließen des Standard-Namespace, um seine Klassen und Funktionen zu verwenden, ohne ihn aufzurufen.
Aufruf der main () -Funktion, innerhalb derer Code hinzugefügt werden soll.
Beginn des Hauptteils der Funktion main ().
Ein Kommentar. Der C ++ - Compiler überspringt dies.
Deklarieren eines 2D-Arrays aus 3 Zeilen und 2 Spalten. Dem Array wurden auch Elemente hinzugefügt.
Ein Kommentar. Der C ++ - Compiler überspringt dies.
Erstellen einer Variablen i mit a für eine Schleife. Diese Variable durchläuft die Zeilenindizes des Arrays.
Erstellen einer Variablen j mit a für eine Schleife. Diese Variable durchläuft die Spaltenindizes des Arrays.
Beginn des Körpers der Schleifen.
Drucken Sie die Werte der Variablen i und j auf der Konsole in eckigen Klammern auf der Konsole.
Drucken Sie den im Index [i] [j] des Arrays a gespeicherten Wert aus.
Ende des Körpers der Schleifen.
Die Funktion main () sollte einen ganzzahligen Wert zurückgeben, wenn das Programm ordnungsgemäß ausgeführt wird.
Ende des Körpers der main () - Funktion.

Dreidimensionales Array
Ein 3D-Array ist ein Array von Arrays. Jedes Element in einem 3D-Array wird durch einen Satz von 3 Indizes identifiziert. Um auf die Elemente eines 3D-Arrays zuzugreifen, verwenden wir drei for-Schleifen. Zum Beispiel:
#includeusing namespace std;void 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";}
Ausgabe:

Hier ist ein Screenshot des Codes:

Code Erläuterung:

Aufnahme der iostream-Header-Datei in unseren Code. Dadurch können wir von der Konsole lesen und darauf schreiben.
Einschließen des Standard-Namespace, um seine Klassen und Funktionen zu verwenden, ohne ihn aufzurufen.
Aufruf der main () -Funktion, in der die Logik des Programms hinzugefügt werden soll.
Beginn des Körpers der main () - Funktion.
Deklarieren eines 3D-Arrays mit der Größe 2x3x2. Die Werte des Arrays wurden ebenfalls initialisiert.
Zugriff auf das im Index [0] [1] [0] des Arrays gespeicherte Element und Drucken auf der Konsole.
Zugriff auf das im Index [0] [1] [1] des Arrays gespeicherte Element und Drucken auf der Konsole.
Ende des Körpers der main () - Funktion.

Zeiger auf ein Array
Ein Zeiger ist eine Variable, die eine Adresse enthält. Anders als die Verwendung eines Zeigers zum Speichern der Adresse einer Variablen können wir ihn zum Speichern der Adresse einer Array-Zelle verwenden. Der Name eines Arrays zeigt ständig auf sein erstes Element. Beachten Sie die folgende Erklärung:
int age[5];
Das Alter ist ein Zeiger auf $ age [0], die Adresse des ersten Elements eines Arrays mit dem Namen age. Betrachten Sie das folgende Beispiel:
#include using namespace std;int main(){int *john;int age[5] = { 19, 18, 21, 20, 17 };john = age;cout << john << "\n";cout << *john;}
Ausgabe:

Beachten Sie, dass der erste Wert der obigen Ausgabe abhängig von der Adresse, die dem ersten Element des Arrays im Arbeitsspeicher Ihres Computers zugewiesen ist, möglicherweise einen anderen Wert zurückgibt.
Hier ist ein Screenshot des Codes:

Code Erläuterung:

Aufnahme der iostream-Header-Datei in unseren Code. Dadurch können wir von der Konsole lesen und darauf schreiben.
Einschließen des Standard-Namespace, um seine Klassen und Funktionen zu verwenden, ohne ihn aufzurufen.
Aufruf der main () -Funktion, in der die Logik des Programms hinzugefügt werden soll.
Beginn des Körpers der main () - Funktion.
Deklarieren einer Zeigervariablen mit dem Namen * john.
Deklarieren eines Ganzzahl-Arrays mit dem Namen age zum Speichern von 5 Ganzzahlen. Die Werte der Ganzzahlen wurden ebenfalls initialisiert.
Zuweisen der Variablen john zum Wert der Adresse des Elements, das im ersten Index des Array-Alters gespeichert ist.
Drucken des Werts der Variablen john, der die Adresse des Elements ist, das im ersten Index des Array-Alters gespeichert ist.
Drucken des ersten im Array-Alter gespeicherten Werts.
Ende des Körpers der main () - Funktion.

Array-Namen können als konstante Zeiger verwendet werden, und umgekehrt ist dies auch der Fall. Dies bedeutet, dass Sie mit * (Alter + 3) auf den im Index 3 des Array-Alters gespeicherten Wert zugreifen können. Zum Beispiel:
#include using namespace std;int main() {// an array of 5 elements.int age[5] = { 19, 18, 21, 20, 17 };int *p;p = age;// output array valuescout << "Using pointer: " << endl;for (int x=0; x<5; x++) {cout << "*(p + " << x << ") : ";cout << *(p + x) << endl;}cout << "Using age as address: " << endl;for (int x = 0; x < 5; x++) {cout << "*(age + " << x << ") : ";cout << *(age + x) << endl;}return 0;}
Ausgabe:

Hier ist ein Screenshot des Codes:

Code Erläuterung:

Aufnahme der iostream-Header-Datei in unseren Code. Dadurch können wir von der Konsole lesen und darauf schreiben.
Einschließen des Standard-Namespace, um seine Klassen und Funktionen zu verwenden, ohne ihn aufzurufen.
Aufruf der main () - Funktion und Start des Körpers der main () - Funktion.
Ein Kommentar. Der C ++ - Compiler überspringt dies.
Deklarieren eines Arrays mit dem Namen age zum Speichern von 5 Ganzzahlen.
Erstellen eines Ganzzahlzeigers p.
Zuweisen von p zum Wert der Adresse des ersten Elements des Array-Alters.
Ein Kommentar. Der C ++ - Compiler überspringt dies.
Drucken Sie Text auf der Konsole aus.
Erstellen Sie eine Ganzzahl x mit a für eine Schleife. Das {markiert den Beginn des Körpers der for-Schleife.
Drucken Sie die Werte von x in Kombination mit einem anderen Text auf der Konsole aus.
Drucken Sie die Werte von * (p + x) auf der Konsole aus.
Ende des Körpers der for-Schleife.
Drucken Sie Text auf der Konsole aus.
Erstellen Sie eine Variable x mit a für eine Schleife. Das {markiert den Beginn des Körpers der for-Schleife.
Drucken Sie die Werte von x von 0 bis 4 zusammen mit einem anderen Text aus.
Drucken Sie die Werte von * (Alter + x) aus.
Ende des Körpers der for-Schleife.
Rückgabewert, wenn das Programm erfolgreich ausgeführt wurde.
Ende des Körpers der main () - Funktion.


Zugriff auf die Werte eines Arrays
Auf die Elemente eines Arrays wird über ihre jeweiligen Indizes zugegriffen. Der Index des Elements, auf das zugegriffen werden soll, wird unmittelbar nach dem Arraynamen in eckigen Klammern [] eingefügt. Zum Beispiel:
int john = age[2];
Im obigen Beispiel geben wir lediglich an, dass Johns Alter im Index 2 des Arrays mit dem Namen age gespeichert ist. Dies bedeutet , dass John das Alter ist der 3 rd Wert im Array Alter. Hier ist ein vollständiges C ++ - Beispiel, das zeigt, wie auf diesen Wert zugegriffen und dieser ausgedruckt wird:
#includeusing namespace std;int main(){int age[5] = { 19, 18, 21, 20, 17 };int john = age[2];cout << "The age of John is:"<
Ausgabe:

Hier ist ein Screenshot des Codes:

Code Erläuterung:

Aufnahme der iostream-Header-Datei in unseren Code. Dadurch können wir von der Konsole lesen und darauf schreiben.
Einschließen des Standard-Namespace, um seine Klassen und Funktionen zu verwenden, ohne ihn aufzurufen.
Aufruf der main () -Funktion, innerhalb derer Code hinzugefügt werden soll.
Start eines Körpers der main () - Funktion.
Deklarieren eines Arrays mit dem Namen age zum Speichern von 5 ganzzahligen Elementen.
Zugreifen auf den im Index 2 des Array-Alters gespeicherten Wert und Speichern seines Werts in einer Variablen namens john.
Drucken des Werts der Variablen John auf der Konsole neben anderem Text.


Vorteile eines Arrays in C ++
Hier sind die Vor- und Nachteile der Verwendung von Array in C ++:

Array-Elemente können problemlos durchlaufen werden.
Einfach zu manipulierende Array-Daten.
Auf Array-Elemente kann zufällig zugegriffen werden.
Arrays erleichtern die Codeoptimierung. Daher können wir viel Arbeit mit weniger Code ausführen.
Einfach zu sortierende Array-Daten.


Nachteile eines Arrays in C ++

Ein Array hat eine feste Größe. Daher können wir nach der Initialisierung keine neuen Elemente hinzufügen.
Das Zuweisen von mehr Speicher als erforderlich führt zu einer Verschwendung von Speicherplatz, und eine geringere Zuweisung von Speicher kann zu einem Problem führen.
Die Anzahl der Elemente, die in einem Array gespeichert werden sollen, muss im Voraus bekannt sein.

Zusammenfassung

Ein Array ist eine Datenstruktur, in der Elemente desselben Datentyps gespeichert werden.
Array-Elemente werden nacheinander gespeichert.
Die Array-Elemente werden mit ihren jeweiligen Indizes bezeichnet. Das erste Element befindet sich am Index 0, während sich das letzte Element am Index n-1 befindet, wobei die Gesamtzahl der Array-Elemente angegeben ist.
Bei der Deklaration eines Arrays werden die Datentypen der Array-Elemente sowie die Anzahl der im Array zu speichernden Elemente definiert.
Ein eindimensionales Array speichert Elemente nacheinander.
Ein zweidimensionales Array speichert Elemente in Zeilen und Spalten.
Ein dreidimensionales Array ist ein Array von Arrays.
Elemente können mithilfe ihrer Indizes zu einem Array hinzugefügt werden.
Auf Array-Elemente wird über ihre Indizes zugegriffen.
Ein mehrdimensionales Array hat mehr als eine Dimension.
Der Arrayname zeigt auf das erste Element.
Arrays haben eine feste Größe, was bedeutet, dass dem Array nach seiner Initialisierung keine neuen Elemente hinzugefügt werden können.