Arrays ein C++ | Deklarieren | Initialisieren | Zeiger auf Array-Beispiele

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++

Array-Deklaration in C++ beinhaltet die Angabe des Typs sowie der Anzahl der Elemente, die im Array gespeichert werden sollen. Syntax:

type array-Name [ array-Size ];

Regeln für die Deklaration eines eindimensionalen Arrays in C++.

• Typ: Der Typ ist der Typ der Elemente, die im Array gespeichert werden sollen, und es muss sich um einen gültigen C++ Datentyp.
• 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 Ganzzahl und größer als 0 sein.

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

int age[5];

Das Array „Alter“ speichert 5 ganze Zahlen, die das Alter verschiedener Schüler darstellen.

Array-Initialisierung

Bei der Array-Initialisierung handelt es sich um den Prozess der Zuweisung/Speicherung von Elementen zu einem Array. Die Initialisierung kann in einer einzelnen Anweisung oder einzeln erfolgen. Beachten Sie, dass das erste Element in einem Array am Index 0 gespeichert wird, während das letzte Element am Index n-1 gespeichert wird, 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 bei Index 0, 18 bei Index 1, 21 bei Index 2, 20 bei Index 3 und 17 bei Index 4. Wenn Sie nicht innerhalb von [] die Anzahl der Elemente angeben, die im Array gespeichert werden sollen, wird 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 über seinen Index ein Element zuweisen. Zum Beispiel:

age[3] = 20;

Die obige Anweisung speichert den Wert 20 am Index 3 des Arrays namens age. Das bedeutet, dass 20 die 4 sein wird^th Element des Arrays.

Arten von Arrays

Es gibt zwei Arten von C++ Arrays:

• Eindimensionales Array
• Mehrdimensionales Array
• Zeiger auf ein Array

Eindimensionales Array

Dabei handelt es sich um 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.

Beispielsweise:

#include <iostream>
using namespace std;

int main()
{
	int age[5] = { 19, 18, 21, 20, 17 };
	for (int x = 0; x < 5; x++)
	{
		cout <<age[x]<<"\n";
	}
}

Ausgang:

Hier ist ein Screenshot des Codes:

Code-Erklärung:

1. Einbinden der iostream-Header-Datei in unseren Code. Dadurch können wir von der Konsole lesen und darauf schreiben.
2. Einschließlich des std-Namespace, um seine Klassen und Funktionen zu verwenden, ohne ihn aufzurufen.
3. Aufruf der Funktion main(), in der die Logik des Programms hinzugefügt werden soll.
4. Beginn des Hauptteils der main()-Funktion.
5. Deklarieren eines Arrays mit dem Namen „age“ zum Speichern von 5 Ganzzahlen. Die 5 Ganzzahlen wurden ebenfalls initialisiert.
6. Erstellen Sie eine ganzzahlige Variable x mithilfe einer for-Schleife.
7. Der Anfang des Körpers der for-Schleife.
8. Verwenden Sie die Schleifenvariable x, um die Werte des Array-Alters zu durchlaufen und sie auf der Konsole auszugeben. „\n“ ist ein Zeilenumbruchzeichen und wird nach jeder Iteration in einer neuen Zeile gedruckt.
9. Ende des Körpers des for-Schleife.
10. Ende des Hauptteils der main()-Funktion.

Mehrdimensionales Array

Dies ist ein Array, in dem Datenelemente so angeordnet sind, dass sie ein Array von Arrays bilden. Ein mehrdimensionales Array kann beliebig viele Dimensionen haben, zweidimensionale und dreidimensionale Arrays sind jedoch üblich. Syntax:

datatype array-name[d1][d2][d3]...[dn];

Der Array-Name ist der Name des Arrays, das n Dimensionen haben wird. Zum Beispiel:

Zweidimensionales Array

Ein 2D-Array speichert Daten in einer Liste mit 1-D-Array. Es ist eine Matrix mit Zeilen und Spalten. Um ein 2D-Array zu deklarieren, verwenden Sie die folgende Syntax:

type array-Name [ x ][ y ];

Der Typ muss ein gültiger C++ Datentyp. Betrachten Sie ein 2D-Array als Tabelle, wobei x die Anzahl der Zeilen und y die Anzahl der Spalten bezeichnet. Das bedeutet, dass Sie jedes Element in einem 2D-Array mithilfe 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 2×3-Matrix betrachtet werden kann. Es gibt 2 Zeilen und 3 Spalten. Auf das Element 0 kann als [0][1] zugegriffen werden, da es sich am Schnittpunkt der Zeile mit dem Index 0 und der Spalte mit dem Index 1 befindet. Auf das Element 3 kann als [1][2] zugegriffen werden, da es sich am Schnittpunkt befindet Schnittpunkt der Zeile mit dem Index 1 und der Spalte mit dem Index 2.

Beachten Sie, dass wir lediglich 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};
   };

Folgende C++ Beispiel zeigt, wie ein 2D-Array initialisiert und durchlaufen wird:

#include <iostream>
using namespace std;
int main() 
{
	// a 2x3 array
	int a[3][2] = { {0, 2}, {1, 4}, {3, 7} };

	// traverse array elements

	for (int i=0; i<3; i++)
		for (int j=0; j<2; j++) 
		
		{
			cout << "a[" <<i<< "][" <<j<< "]: ";
			cout << a[i][j] << endl;
		}
	return 0;
}

Ausgang:

Hier ist ein Screenshot des obigen Codes:

Code-Erklärung:

1. Einbinden der iostream-Header-Datei in unseren Code. Dadurch können wir von der Konsole lesen und darauf schreiben.
2. Einschließlich des std-Namespace, um seine Klassen und Funktionen zu verwenden, ohne ihn aufzurufen.
3. Aufrufen der main()-Funktion, innerhalb derer Code hinzugefügt werden soll.
4. Beginn des Hauptteils der main()-Funktion.
5. Ein Kommentar. Die C++ Der Compiler überspringt dies.
6. Deklarieren eines 2D-Arrays mit 3 Zeilen und 2 Spalten. Dem Array wurden auch Elemente hinzugefügt.
7. Ein Kommentar. Die C++ Der Compiler überspringt dies.
8. Zum Erstellen einer Variablen verwende ich eine for-Schleife. Diese Variable durchläuft die Zeilenindizes des Arrays.
9. Erstellen einer Variablen j mithilfe einer for-Schleife. Diese Variable durchläuft die Spaltenindizes des Arrays.
10. Beginn des Schleifenkörpers.
11. Drucken Sie die Werte der Variablen i und j in eckigen Klammern auf der Konsole.
12. Geben Sie den am Index [i][j] des Arrays a gespeicherten Wert aus.
13. Ende des Schleifenkörpers.
14. Die Funktion main() sollte einen ganzzahligen Wert zurückgeben, wenn das Programm einwandfrei läuft.
15. Ende des Hauptteils 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:

#include<iostream>
using 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";
}

Ausgang:

Hier ist ein Screenshot des Codes:

Code-Erklärung:

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

Zeiger auf ein Array

A Zeiger ist eine Variable, die eine Adresse enthält. Anstatt einen Zeiger zum Speichern der Adresse einer Variablen zu verwenden, können wir ihn auch zum Speichern der Adresse einer Array-Zelle verwenden. Der Name eines Arrays verweist ständig auf sein erstes Element. Betrachten 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 <iostream>
using namespace std;
int main()
{
	int *john;

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

	john = age;

	cout << john << "\n";

	cout << *john;
	
}

Ausgang:

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

Hier ist ein Screenshot des Codes:

Code-Erklärung:

1. Einbinden der iostream-Header-Datei in unseren Code. Dadurch können wir von der Konsole lesen und darauf schreiben.
2. Einschließlich des std-Namespace, um seine Klassen und Funktionen zu verwenden, ohne ihn aufzurufen.
3. Aufruf der Funktion main(), in der die Logik des Programms hinzugefügt werden soll.
4. Beginn des Hauptteils der main()-Funktion.
5. Deklarieren einer Zeigervariablen namens *john.
6. Deklarieren eines Ganzzahl-Arrays mit dem Namen „age“ zum Speichern von 5 Ganzzahlen. Die Werte der Ganzzahlen wurden ebenfalls initialisiert.
7. Weisen Sie der Variablen John den Wert der Adresse des Elements zu, das im ersten Index des Array-Alters gespeichert ist.
8. Gibt den Wert der Variablen john aus, bei der es sich um die Adresse des Elements handelt, das im ersten Index des Array-Alters gespeichert ist.
9. Drucken des ersten im Array-Alter gespeicherten Werts.
10. Ende des Hauptteils der main()-Funktion.

Array-Namen können als konstante Zeiger verwendet werden, und umgekehrt gilt dies auch. Dies bedeutet, dass Sie mit *(Alter + 3) auf den am Index 3 des Array-Alters gespeicherten Wert zugreifen können. Zum Beispiel:

#include <iostream>
using namespace std;

int main() {
	// an array of 5 elements.
	int age[5] = { 19, 18, 21, 20, 17 };
	int *p;

	p = age;

	// output array values

	cout << "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;
}

Ausgang:

Hier ist ein Screenshot des Codes:

Code-Erklärung:

1. Einbinden der iostream-Header-Datei in unseren Code. Dadurch können wir von der Konsole lesen und darauf schreiben.
2. Einschließlich des std-Namespace, um seine Klassen und Funktionen zu verwenden, ohne ihn aufzurufen.
3. Aufruf der Funktion main() und Beginn des Hauptteils der Funktion main().
4. Ein Kommentar. Die C++ Der Compiler überspringt dies.
5. Deklarieren eines Arrays mit dem Namen „age“ zum Speichern von 5 Ganzzahlen.
6. Erstellen eines Integer-Zeigers p.
7. Weisen Sie p den Wert der Adresse des ersten Elements des Array-Alters zu.
8. Ein Kommentar. Die C++ Der Compiler überspringt dies.
9. Drucken Sie einen Text auf der Konsole aus.
10. Erstellen Sie eine Ganzzahl x mithilfe einer for-Schleife. Das { markiert den Anfang des Rumpfes der for-Schleife.
11. Geben Sie die Werte von x kombiniert mit einem anderen Text auf der Konsole aus.
12. Geben Sie die Werte von *(p + x) auf der Konsole aus.
13. Ende des Körpers der for-Schleife.
14. Drucken Sie einen Text auf der Konsole aus.
15. Erstellen Sie eine Variable x mithilfe einer for-Schleife. Das { markiert den Anfang des Rumpfes der for-Schleife.
16. Geben Sie die x-Werte von 0 bis 4 zusammen mit einem anderen Text aus.
17. Drucken Sie die Werte von *(Alter + x) aus.
18. Ende des Körpers der for-Schleife.
19. Rückgabewert, wenn das Programm erfolgreich ausgeführt wird.
20. Ende des Hauptteils 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 in eckigen Klammern [ ] unmittelbar nach dem Array-Namen hinzugefügt. Beispiel:

int john = age[2];

Im obigen Beispiel geben wir einfach an, dass Johns Alter auf Index 2 des Arrays mit dem Namen „Alter“ gespeichert wird. Das bedeutet, dass John 3 Jahre alt ist^rd Wert im Array Alter. Hier ist eine vollständige C++ Beispiel, das zeigt, wie man auf diesen Wert zugreift und ihn ausdruckt:

#include<iostream>
using namespace std;
int main()
{
	int age[5] = { 19, 18, 21, 20, 17 };
	int john = age[2];
	cout << "The age of John is:"<<john;
}

Ausgang:

Hier ist ein Screenshot des Codes:

Code-Erklärung:

1. Einbinden der iostream-Header-Datei in unseren Code. Dadurch können wir von der Konsole lesen und darauf schreiben.
2. Einschließlich des std-Namespace, um seine Klassen und Funktionen zu verwenden, ohne ihn aufzurufen.
3. Aufrufen der main()-Funktion, innerhalb derer Code hinzugefügt werden soll.
4. Beginn eines Hauptteils der main()-Funktion.
5. Deklarieren eines Arrays mit dem Namen „age“ zum Speichern von 5 ganzzahligen Elementen.
6. Greifen Sie auf den am Index 2 des Array-Alters gespeicherten Wert zu und speichern Sie seinen Wert in einer Variablen namens john.
7. Drucken des Werts der Variablen john auf der Konsole zusammen mit anderem Text.

Vorteile eines Arrays in C++

Hier sind die Vorteile 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 erledigen.
• 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.
• Die Zuweisung von mehr Speicher als erforderlich führt zur Verschwendung von Speicherplatz, und eine geringere Zuweisung von Speicher kann zu Problemen führen.
• Die Anzahl der in einem Array zu speichernden Elemente muss im Voraus bekannt sein.

Zusammenfassung

• Ein Array ist eine Datenstruktur, die Elemente desselben Datentyps speichert.
• Array-Elemente werden sequentiell gespeichert.
• Die Array-Elemente werden mit ihren jeweiligen Indizes bezeichnet. Das erste Element befindet sich am Index 0, während das letzte Element am Index n-1 liegt, wobei es sich um die Gesamtzahl der Array-Elemente handelt.
• 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.
• Der Zugriff auf Array-Elemente erfolgt über ihre Indizes.
• Ein mehrdimensionales Array hat mehr als eine Dimension.
• Der Array-Name zeigt auf sein erstes Element.
• Arrays haben eine feste Größe, was bedeutet, dass dem Array nach seiner Initialisierung keine neuen Elemente hinzugefügt werden können.