In C++ ist ein Array eine Datenstruktur, die zum Speichern mehrerer Werte ähnlicher Datentypen an einem zusammenhängenden Speicherort verwendet wird.

Zum Beispiel Wenn wir die Noten von 4 oder 5 Schülern speichern müssen, können wir sie einfach speichern, indem wir 5 verschiedene Variablen erstellen. Wenn wir jedoch die Noten von 100 oder sagen wir 500 Schülern speichern möchten, wird es sehr schwierig, diese Anzahl von Variablen zu erstellen und sie verwalten. Jetzt kommen Arrays ins Spiel, mit denen dies ganz einfach möglich ist, indem einfach ein Array mit der erforderlichen Größe erstellt wird.

Eigenschaften von Arrays in C++

• Ein Array ist eine Sammlung von Daten desselben Datentyps, die an einem zusammenhängenden Speicherort gespeichert werden.
• Die Indizierung eines Arrays beginnt bei 0. Das bedeutet, dass das erste Element am 0. Index gespeichert wird, das zweite am 1. und so weiter.
• Auf Elemente eines Arrays kann über ihre Indizes zugegriffen werden.
• Sobald ein Array deklariert ist, bleibt seine Größe im gesamten Programm konstant.
• Ein Array kann mehrere Dimensionen haben.
• Die Größe des Arrays in Bytes kann durch den Operator „sizeof“ bestimmt werden, mit dem wir auch die Anzahl der Elemente im Array ermitteln können.
• Wir können die Größe der in einem Array gespeicherten Elementtypen ermitteln, indem wir benachbarte Adressen subtrahieren.

Array-Deklaration in C++

In C++ können wir ein Array deklarieren, indem wir einfach zuerst den Datentyp und dann den Namen eines Arrays mit seiner Größe angeben.

data_type array_name[Size_of_array];>

Beispiel

int arr[5];>

Hier,

• int: Dies ist der Datentyp, der im Array gespeichert werden soll. Wir können auch andere Datentypen wie char, float und double verwenden.
• arr: Es ist der Name des Arrays.
• 5: Dies ist die Größe des Arrays, was bedeutet, dass nur 5 Elemente im Array gespeichert werden können.

Initialisierung eines Arrays in C++

In C++ können wir ein Array auf viele Arten initialisieren, wir werden jedoch einige der gängigsten Methoden zur Initialisierung eines Arrays besprechen. Wir können ein Array zum Zeitpunkt der Deklaration oder nach der Deklaration initialisieren.

1. Array mit Werten in C++ initialisieren

Wir haben das Array mit Werten initialisiert. Die in geschweiften Klammern „{}“ eingeschlossenen Werte werden dem Array zugewiesen. Hier wird 1 in arr[0], 2 in arr[1] usw. gespeichert. Hier beträgt die Größe des Arrays 5.

int arr[5] = {1, 2, 3, 4, 5};>

2. Array mit Werten und ohne Größe in C++ initialisieren

Wir haben das Array mit Werten initialisiert, aber die Länge des Arrays nicht deklariert. Daher ist die Länge eines Arrays gleich der Anzahl der Elemente in geschweiften Klammern.

Git-Push-Befehl

int arr[] = {1, 2, 3, 4, 5};>

3. Array nach der Deklaration initialisieren (mithilfe von Schleifen)

Wir haben das Array nach der Deklaration des Arrays mithilfe einer Schleife initialisiert. Diese Methode wird im Allgemeinen verwendet, wenn wir Eingaben vom Benutzer entgegennehmen möchten oder nicht jedem Index des Arrays Elemente einzeln zuweisen können. Wir können die Schleifenbedingungen ändern oder die Initialisierungswerte entsprechend den Anforderungen ändern.

for (int i = 0; i   arr[i] = value; }>

4. Initialisieren Sie ein Array teilweise in C++

Hier haben wir ein Array „partialArray“ mit der Größe „5“ und nur den Werten „1“ und „2“ deklariert. Diese Werte werden also an den ersten beiden Indizes gespeichert und an den restlichen Indizes wird „0“ gespeichert.

int partialArray[5] = {1, 2};>

5. Initialisieren Sie das Array in C++ mit Null

Wir können das Array mit allen Elementen als „0“ initialisieren, indem wir „0“ in den geschweiften Klammern angeben. Dies geschieht im Fall von Null nur, wenn wir versuchen, das Array mit dieser Methode mit einem anderen Wert, beispielsweise „2“, zu initialisieren, dann wird „2“ nur am 0. Index gespeichert.

int zero_array[5] = {0};>

Zugreifen auf ein Element eines Arrays in C++

Auf Elemente eines Arrays kann zugegriffen werden, indem der Name des Arrays und dann der Index des Elements angegeben werden, der im Array-Indexoperator [] eingeschlossen ist. Beispiel: arr[i].

Beispiel 1: Das C++-Programm zur Veranschaulichung des Zugriffs auf Array-Elemente

// C++ Program to Illustrate How to Access Array Elements #include  using namespace std; int main() {  int arr[3];  // Inserting elements in an array  arr[0] = 10;  arr[1] = 20;  arr[2] = 30;  // Accessing and printing elements of the array  cout << 'arr[0]: ' << arr[0] << endl;  cout << 'arr[1]: ' << arr[1] << endl;  cout << 'arr[2]: ' << arr[2] << endl;  return 0; }>

arr[0]: 10 arr[1]: 20 arr[2]: 30>

Array-Element aktualisieren

Um ein Element in einem Array zu aktualisieren, können wir den Index, den wir aktualisieren möchten, innerhalb des Array-Indexoperators verwenden und den neuen Wert zuweisen.

arr[i] = new_value;>

Durchlaufen Sie ein Array in C++

Wir können das Array mit Hilfe einer Schleife durchlaufen Verwenden der Indizierung in C++. Zuerst haben wir ein Array „table_of_two“ mit einem Vielfachen von 2 initialisiert. Danach führen wir eine for-Schleife von 0 bis 9 aus, da in einem Array die Indizierung bei Null beginnt. Daher drucken wir mithilfe der Indizes alle in einem Array gespeicherten Werte aus.

Beispiel 2: Das C++-Programm zur Veranschaulichung des Durchlaufens eines Arrays

// C++ Program to Illustrate How to Traverse an Array #include  using namespace std; int main() {  // Initialize the array  int table_of_two[10]  = { 2, 4, 6, 8, 10, 12, 14, 16, 18, 20 };  // Traverse the array using for loop  for (int i = 0; i < 10; i++) {  // Print the array elements using indexing  cout << table_of_two[i] << ' ';  }  return 0; }>

2 4 6 8 10 12 14 16 18 20>

Größe eines Arrays in C++

In C++ haben wir nicht wie in Java die Längenfunktion, um die Array-Größe zu ermitteln, sondern Wir können die Größe eines Arrays mit dem Operator sizeof() berechnen Trick. Zuerst ermitteln wir die Größe, die das gesamte Array im Speicher einnimmt, und teilen sie dann durch die Größe des im Array gespeicherten Elementtyps. Dadurch erhalten wir die Anzahl der im Array gespeicherten Elemente.

data_type size = sizeof(Array_name) / sizeof(Array_name[index]);>

Beispiel 3: Das C++-Programm zur Veranschaulichung, wie man die Größe eines Arrays ermittelt

// C++ Program to Illustrate How to Find the Size of an // Array #include  using namespace std; int main() {  int arr[] = { 1, 2, 3, 4, 5 };  // Size of one element of an array  cout << 'Size of arr[0]: ' << sizeof(arr[0]) << endl;  // Size of array 'arr'  cout << 'Size of arr: ' << sizeof(arr) << endl;  // Length of an array  int n = sizeof(arr) / sizeof(arr[0]);  cout << 'Length of an array: ' << n << endl;  return 0; }>

Size of arr[0]: 4 Size of arr: 20 Length of an array: 5>

Beziehung zwischen Arrays und Zeigern in C++

In C++ sind Arrays und Zeiger eng miteinander verbunden. Der Array-Name wird als Zeiger behandelt, der die Speicheradresse des ersten Elements des Arrays speichert. Wie wir bereits besprochen haben, werden In-Array-Elemente an zusammenhängenden Speicherorten gespeichert, weshalb wir über den Array-Namen auf alle Elemente eines Arrays zugreifen können.

Beispiel 4: Veranschaulichung der Beziehung zwischen Array und Zeigern

// C++ Program to Illustrate that Array Name is a Pointer // that Points to First Element of the Array #include  using namespace std; int main() {  // Defining an array  int arr[] = { 1, 2, 3, 4 };  // Define a pointer  int* ptr = arr;  // Printing address of the arrary using array name  cout << 'Memory address of arr: ' << &arr << endl;  // Printing address of the array using ptr  cout << 'Memory address of arr: ' << ptr << endl;  return 0; }>

Memory address of arr: 0x7fff2f2cabb0 Memory address of arr: 0x7fff2f2cabb0>

Erläuterung:

Im obigen Code definieren wir zunächst ein Array arr und dann einen Zeiger deklarieren ptr und weisen Sie ihm das Array arr zu. Wir können arr ptr zuweisen, da arr auch ein Zeiger ist. Danach drucken wir die Speicheradresse von aus arr unter Verwendung des Referenzoperators ( & ) und drucken Sie auch die im Zeiger gespeicherte Adresse aus ptr und wir können sehen, dass arr und ptr beide dieselbe Speicheradresse speichern.

Beispiel 5: Array-Elemente ohne Indizierung in C++ drucken

Wir greifen im Allgemeinen mithilfe der Indizierung auf die Array-Elemente zu und drucken sie aus. Zum Beispiel, um auf das erste Element zuzugreifen, das wir verwenden array_name[0]. Wir haben oben besprochen, dass der Array-Name ein Zeiger ist, der die Adresse des ersten Elements speichert und Array-Elemente an zusammenhängenden Orten gespeichert werden. Jetzt greifen wir nur über den Array-Namen auf die Elemente eines Arrays zu.

// C++ Program to Print Array Elements without Indexing #include  using namespace std; int main() {  // Define an array  int arr[] = { 11, 22, 33, 44 };  // Print elements of an array  cout << 'first element: ' << *arr << endl;  cout << 'Second element: ' << *(arr + 1) << endl;  cout << 'Third element: ' << *(arr + 2) << endl;  cout << 'fourth element: ' << *(arr + 3) << endl;  return 0; }>

first element: 11 Second element: 22 Third element: 33 fourth element: 44>

Erläuterung

Im obigen Code haben wir zunächst ein Array deklariert arr mit vier Elementen. Danach drucken wir die Array-Elemente. Lassen Sie uns besprechen, wie wir es machen. Wir haben besprochen, dass der Array-Name ein Zeiger ist, der die Adresse des ersten Elements eines Arrays speichert. Um das erste Element auszugeben, haben wir diesen Zeiger dereferenziert (*arr) Verwendung des Dereferenzierungsoperators (*) Dadurch werden die an dieser Adresse gespeicherten Daten ausgedruckt.

Um das zweite Element eines Arrays zu drucken, fügen wir zuerst hinzu 1 Zu arr Dies entspricht (Adresse von arr + size_of_one_element *1), die den Zeiger auf die Adresse direkt nach dem ersten nimmt, und danach dereferenzieren wir diesen Zeiger, um das zweite Element zu drucken. Ebenso drucken wir die restlichen Elemente eines Arrays ohne Indizierung.

Übergeben eines Arrays an eine Funktion in C++

Um Arrays effizient nutzen zu können, sollten wir wissen, wie man Arrays an eine Funktion übergibt. Wir können Arrays auf die gleiche Weise als Argument an Funktionen übergeben wie Variablen an Funktionen, aber wir wissen, dass der Array-Name als Zeiger behandelt wird. Mit diesem Konzept können wir das Array als Argument an Funktionen übergeben und dann mit auf alle Elemente dieses Arrays zugreifen Zeiger.

Letztendlich also Arrays werden immer als Zeiger an die Funktion übergeben. Sehen wir uns drei Möglichkeiten an, ein Array an eine Funktion zu übergeben, die am häufigsten verwendet werden.

1. Array als Zeiger übergeben

Bei dieser Methode übergeben wir einfach den Array-Namen im Funktionsaufruf, was bedeutet, dass wir die Adresse an das erste Element des Arrays übergeben. Bei dieser Methode können wir die Array-Elemente innerhalb der Funktion ändern.

Syntax

return_type   function_name   (   data_type *array_name   ) {     // set of statements  }>

2. Array als Array ohne Größe übergeben

Bei dieser Methode akzeptiert die Funktion das Array mit einer einfachen Array-Deklaration ohne Größe als Argument.

Syntax

return_type   function_name    ( data_type array_name[]   ) {    // set of statements  }>

3. Array als Array mit Größe übergeben

Bei dieser Methode akzeptiert die Funktion das Array mithilfe einer einfachen Array-Deklaration mit der Größe als Argument. Wir verwenden diese Methode, indem wir die Größe eines Arrays nur anpassen, um die Größe eines Arrays anzuzeigen.

Syntax

return_type function_name(data_type array_name[size_of_array]){  // set of statements }>

Notiz: Das Array wird in der übergebenen Funktion als Zeiger behandelt, unabhängig davon, welche Methode wir verwenden. Wenn das Array als Zeiger übergeben wird, gehen die Informationen über seine Größe verloren, was zu einem Phänomen mit dem Namen führt Array-Zerfall.

Beispiel: Veranschaulichung verschiedener Möglichkeiten, Arrays an eine Funktion zu übergeben

#include  using namespace std; // passing array as a sized array argument void printArraySized(int arr[3], int n) {  cout << 'Array as Sized Array Argument: ';  for (int i = 0; i < n; i++) {  cout << arr[i] << ' ';  }  cout << endl; } // passing array as an unsized array argument void printArrayUnsized(int arr[], int n) {  cout << 'Array as Unsized Array Argument: ';  for (int i = 0; i < n; i++) {  cout << *(arr + i) << ' ';  }  cout << endl; } // Passing array as a pointer argument void printArrayPointer(int* ptr, int n) {  // Print array elements using pointer ptr  // that store the address of array passed  cout << 'Array as Pointer Argument: ';  for (int i = 0; i < n; i++) {  cout << ptr[i] << ' ';  } } // driver code int main() {  int arr[] = { 10, 20, 30 };  // Call function printArray and pass  // array and its size to it.  printArraySized(arr, 3);  printArrayUnsized(arr, 3);  printArrayPointer(arr, 3);  return 0; }>

Array as Sized Array Argument: 10 20 30 Array as Unsized Array Argument: 10 20 30 Array as Pointer Argument: 10 20 30>

Mehrdimensionale Arrays in C++

Mit mehr als einer Dimension deklarierte Arrays werden als mehrdimensionale Arrays bezeichnet. Die am häufigsten verwendeten mehrdimensionalen Arrays sind 2D-Arrays und 3D-Arrays. Diese Arrays werden im Allgemeinen in Form von Zeilen und Spalten dargestellt.

Mehrdimensionale Array-Deklaration

Data_Type Array_Name[Size1][Size2]...[SizeN];>

Wo,

• Datentyp: Art der im Array zu speichernden Daten.
• Array_Name: Name des Arrays.
• Größe1, Größe2,…, GrößeN: Größe jeder Dimension.

Zweidimensionales Array in C++

In C++ ist ein zweidimensionales Array eine Gruppierung von Elementen, die in Zeilen und Spalten angeordnet sind. Der Zugriff auf jedes Element erfolgt über zwei Indizes: einen für die Zeile und einen für die Spalte, was die Visualisierung als Tabelle oder Raster erleichtert.

Syntax eines 2D-Arrays

data_Type array_name[n][m];>

Wo,

• N: Anzahl der Reihen.
• M: Anzahl der Spalten.
  

Beispiel: Das C++-Programm zur Veranschaulichung des zweidimensionalen Arrays

// c++ program to illustrate the two dimensional array #include  using namespace std; int main() {  // Declaring 2D array  int arr[4][4];  // Initialize 2D array using loop  for (int i = 0; i < 4; i++) {  for (int j = 0; j < 4; j++) {  arr[i][j] = i + j;  }  }  // Printing the element of 2D array  for (int i = 0; i < 4; i++) {  for (int j = 0; j < 4; j++) {  cout << arr[i][j] << ' ';  }  cout << endl;  }  return 0; }>

0 1 2 3 1 2 3 4 2 3 4 5 3 4 5 6>

Erläuterung

Im obigen Code haben wir ein 2D-Array mit 4 Zeilen und 4 Spalten deklariert und anschließend das Array in jeder Iteration der Schleife mit dem Wert (i+j) initialisiert. Dann drucken wir das 2D-Array mithilfe einer verschachtelten Schleife und können in der folgenden Ausgabe sehen, dass es 4 Zeilen und 4 Spalten gibt.

Dreidimensionales Array in C++

Das 3D-Array verwendet drei Dimensionen. Zur Darstellung kann eine Sammlung verschiedener übereinander gestapelter zweidimensionaler Arrays verwendet werden. Drei Indizes – der Zeilenindex, der Spaltenindex und der Tiefenindex – werden verwendet, um jedes Element in einem 3D-Array eindeutig zu identifizieren.

Deklaration eines dreidimensionalen Arrays in C++

Um ein 3D-Array in C++ zu deklarieren, müssen wir seine dritte Dimension zusammen mit den 2D-Dimensionen angeben.

Data_Type Array_Name[D][R][C];>

Wo,

• Datentyp: Art der Daten, die in jedem Element gespeichert werden sollen.
• Array_Name: Name des Arrays
• D: Anzahl der 2D-Arrays oder Tiefe des Arrays.
• R: Anzahl der Zeilen in jedem 2D-Array.
• C: Anzahl der Spalten in jedem 2D-Array.

Beispiel

int array[3][3][3];>

Beispiel: Das C++-Programm zur Veranschaulichung des 3D-Arrays

// C++ program to illustrate the 3d array #include  using namespace std; int main() {  // declaring 3d array  int arr[3][3][3];  // initializing the array  for (int i = 0; i < 3; i++) {  for (int j = 0; j < 3; j++) {  for (int k = 0; k < 3; k++) {  arr[i][j][k] = i + j + k;  }  }  }  // printing the array  for (int i = 0; i < 3; i++) {  cout << i << 'st layer:' << endl;  for (int j = 0; j < 3; j++) {  for (int k = 0; k < 3; k++) {  cout << arr[i][j][k] << ' ';  }  cout << endl;  }  cout << endl;  }  return 0; }>

0st layer: 0 1 2 1 2 3 2 3 4 1st layer: 1 2 3 2 3 4 3 4 5 2st layer: 2 3 4 3 4 5 4 5 6>

Erläuterung

Im obigen Code haben wir ein 3D-Array deklariert und es dann mit drei verschachtelten for-Schleifen initialisiert. Danach haben wir alle Ebenen des 3D-Arrays erneut gedruckt und dabei drei verschachtelte for-Schleifen verwendet, wie in der Ausgabe zu sehen ist.

In Verbindung stehende Artikel

• Mehrdimensionale Arrays in C++
• Eigenschaften von Array
• Array-Zerfall