Arrays in C++ | Erklären | Initialisieren | Zeiger auf Array-Beispiele

Was ist ein Array?

Ein Array ist eine Datenstruktur, die ein Element desselben Datentyps sequentiell speichert. Ein C++-Array hat eine feste Größe.

Sie können ein Array als eine Sammlung von Variablen eines ähnlichen Datentyps sehen. Anstatt jede Variable einzeln zu deklarieren und ihr einen Wert zuzuweisen, können Sie eine Variable (das Array) deklarieren und ihr die Werte der verschiedenen Variablen hinzufügen. Jeder dem Array hinzugefügte Wert 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++

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

type array-Name [ array-Size ];

Regeln zum Deklarieren eines eindimensionalen Arrays in C++.

• Typ: Der Typ ist der Typ der im Array zu speichernden Elemente und muss ein gültiger C++-Datentyp sein.
• Array-Name: Der Array-Name ist der dem Array zuzuweisende Name.
• 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 Ganzzahlen, die das Alter verschiedener Schüler darstellen.

Array-Initialisierung

Die Array-Initialisierung ist der Vorgang des Zuweisens/Speicherns von Elementen zu einem Array. Die Initialisierung kann in einer einzelnen Anweisung oder nacheinander 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 Array age verwenden, um zu demonstrieren, wie eine Array-Initialisierung durchgeführt werden kann:

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

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

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

Die obige Anweisung erstellt genau dasselbe Array wie die vorherige. Sie können einem Array auch ein Element über seinen Index zuweisen. Zum Beispiel:

age[3] = 20;

Die obige Anweisung speichert den Wert 20 an Index 3 des Arrays namens age. Das bedeutet, dass die 20 die 4 ^te sein wird 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 <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";
	}
}

Ausgabe:

Hier ist ein Screenshot des Codes:

Code-Erklärung:

1. Einschließen der iostream-Header-Datei in unseren Code. Es ermöglicht uns, von der Konsole zu lesen und in sie zu schreiben.
2. Einschließen des std-Namensraums, 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 Funktion main().
5. Ein Array namens Alter deklarieren, um 5 Ganzzahlen zu speichern. Die 5 Ganzzahlen wurden ebenfalls initialisiert.
6. Erstellen Sie eine Integer-Variable x mit einer for-Schleife.
7. Der Anfang des Hauptteils der for-Schleife.
8. Die Schleifenvariable x verwenden, um über die Werte des Arrays age zu iterieren und sie auf der Konsole auszugeben. Das „\n“ ist ein Zeilenumbruchzeichen und druckt nach jeder Iteration in einer neuen Zeile.
9. Ende des Körpers der 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 eine beliebige Anzahl von Dimensionen haben, aber zweidimensionale und dreidimensionale Arrays sind ü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 einem 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 sein. Sehen Sie sich ein 2D-Array als Tabelle an, wobei x die Anzahl der Zeilen und y die Anzahl der Spalten bezeichnet. Das 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 2×3-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 der mit 0 indizierten Zeile und der mit 1 indizierten Spalte befindet. Auf das Element 3 kann als [1][2] zugegriffen werden, da es sich an der befindet Schnittpunkt von Zeile mit Index 1 und Spalte mit Index 2.

Beachten Sie, dass wir einfach geschweifte Klammern hinzugefügt haben, um die verschiedenen Zeilen von Elementen zu unterscheiden. Die Initialisierung hätte auch folgendermaßen 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 <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;
}

Ausgabe:

Hier ist ein Screenshot des obigen Codes:

Code-Erklärung:

1. Einschließen der iostream-Header-Datei in unseren Code. Es ermöglicht uns, von der Konsole zu lesen und in sie zu schreiben.
2. Einschließen des std-Namensraums, um seine Klassen und Funktionen zu verwenden, ohne ihn aufzurufen.
3. Aufruf der main()-Funktion, innerhalb derer Code hinzugefügt werden soll.
4. Beginn des Hauptteils der Funktion main().
5. Ein Kommentar. Der C++-Compiler überspringt dies.
6. Ein 2D-Array mit 3 Zeilen und 2 Spalten deklarieren. Dem Array wurden auch Elemente hinzugefügt.
7. Ein Kommentar. Der C++-Compiler wird dies überspringen.
8. Erstellen einer Variablen i mit einer for-Schleife. Diese Variable iteriert über die Zeilenindizes des Arrays.
9. Erstellen einer Variablen j mit einer for-Schleife. Diese Variable iteriert über die Spaltenindizes des Arrays.
10. Beginn des Schleifenkörpers.
11. Gib die Werte der Variablen i und j auf der Konsole in eckigen Klammern auf der Konsole aus.
12. Gib den Wert aus, der bei Index [i][j] des Arrays a gespeichert ist.
13. Ende des Schleifenkörpers.
14. Die Funktion main() sollte einen ganzzahligen Wert zurückgeben, wenn das Programm gut läuft.
15. Ende des Hauptteils der Funktion main().

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

Ausgabe:

Hier ist ein Screenshot des Codes:

Code-Erklärung:

1. Einschließen der iostream-Header-Datei in unseren Code. Es ermöglicht uns, von der Konsole zu lesen und in sie zu schreiben.
2. Einschließen des std-Namensraums, 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 Funktion main().
5. Deklaration eines 3D-Arrays mit dem Namen an der Größe 2x3x2. Die Werte des Arrays wurden ebenfalls initialisiert.
6. Zugriff auf das unter Index [0][1][0] des Arrays gespeicherte Element und Ausdruck auf der Konsole.
7. Zugriff auf das unter Index [0][1][1] des Arrays gespeicherte Element und Ausdruck auf der Konsole.
8. Ende des Hauptteils 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. Betrachten Sie die folgende Deklaration:

int age[5];

Das Alter ist ein Zeiger auf $age[0], die Adresse des ersten Elements eines Arrays namens 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;
	
}

Ausgabe:

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, einen anderen Wert zurückgeben kann.

Hier ist ein Screenshot des Codes:

Code-Erklärung:

1. Einschließen der iostream-Header-Datei in unseren Code. Es ermöglicht uns, von der Konsole zu lesen und in sie zu schreiben.
2. Einschließen des std-Namensraums, 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 Funktion main().
5. Eine Zeigervariable namens *john deklarieren.
6. Ein Integer-Array namens Alter deklarieren, um 5 Integer zu speichern. Die Werte der ganzen Zahlen wurden ebenfalls initialisiert.
7. Der Variablen john den Wert der Adresse des Elements zuweisen, das im ersten Index des Arrays age gespeichert ist.
8. Drucken des Werts der Variablen john, die die Adresse des Elements ist, das im ersten Index des Arrays age gespeichert ist.
9. Drucken des ersten im Array age gespeicherten Wertes.
10. Ende des Hauptteils der main()-Funktion.

Array-Namen können als konstante Zeiger verwendet werden, und umgekehrt gilt auch. Das bedeutet, dass Sie mit *(age + 3) auf den Wert zugreifen können, der bei Index 3 des Arrays age gespeichert ist. 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;
}

Ausgabe:

Hier ist ein Screenshot des Codes:

Code-Erklärung:

1. Einschließen der iostream-Header-Datei in unseren Code. Es ermöglicht uns, von der Konsole zu lesen und in sie zu schreiben.
2. Einschließen des std-Namensraums, 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. Der C++-Compiler überspringt dies.
5. Ein Array namens Alter deklarieren, um 5 Ganzzahlen zu speichern.
6. Erstellen eines Integer-Zeigers p.
7. P den Wert der Adresse des ersten Elements des Arrays age zuweisen.
8. Ein Kommentar. Der C++-Compiler überspringt dies.
9. Einen Text auf der Konsole ausdrucken.
10. Erzeuge eine Ganzzahl x mit einer for-Schleife. Das { markiert den Anfang des Körpers der for-Schleife.
11. Geben Sie die Werte von x in Kombination mit anderem 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. Einen Text auf der Konsole ausdrucken.
15. Erstellen Sie eine Variable x mit einer for-Schleife. Das { markiert den Beginn des Körpers der for-Schleife.
16. Drucken Sie die x-Werte von 0 bis 4 zusammen mit anderem Text aus.
17. Drucke die Werte von *(Alter + x).
18. Ende des Körpers der for-Schleife.
19. Rückgabewert, wenn das Programm erfolgreich läuft.
20. Ende des Hauptteils der main()-Funktion.

Auf die Werte eines Arrays zugreifen

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. Zum Beispiel:

int john = age[2];

Im obigen Beispiel geben wir einfach an, dass das Alter von John an Index 2 des Arrays mit dem Namen Alter gespeichert ist. Das bedeutet, dass Hans das 3. Alter ist Wert im Array age. Hier ist ein vollständiges C++-Beispiel, das zeigt, wie Sie auf diesen Wert zugreifen und ihn ausdrucken:

#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;
}

Ausgabe:

Hier ist ein Screenshot des Codes:

Code-Erklärung:

1. Einschließen der iostream-Header-Datei in unseren Code. Es ermöglicht uns, von der Konsole zu lesen und in sie zu schreiben.
2. Einschließen des std-Namensraums, um seine Klassen und Funktionen zu verwenden, ohne ihn aufzurufen.
3. Aufruf der main()-Funktion, innerhalb derer Code hinzugefügt werden soll.
4. Beginn eines Hauptteils der Funktion main().
5. Ein Array namens Alter deklarieren, um 5 Integer-Elemente zu speichern.
6. Zugriff auf den Wert, der bei Index 2 des Arrays alter gespeichert ist, und Speichern seines Werts 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/Vorteile der Verwendung von Array in C++:

• Array-Elemente können leicht durchlaufen werden.
• Einfache Bearbeitung von Array-Daten.
• Auf Array-Elemente kann wahlfrei zugegriffen werden.
• Arrays erleichtern die Codeoptimierung; Daher können wir viel Arbeit mit weniger Code ausführen.
• Einfaches Sortieren von 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.
• Wenn Sie mehr Speicher als erforderlich zuweisen, wird Speicherplatz verschwendet, und eine geringere Speicherzuweisung 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 hat den Index 0, das letzte Element den Index n-1, wo die Gesamtzahl der Array-Elemente steht.
• 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 sequentiell.
• 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 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.