Grundlagen von C++-Arrays

Einführung

In diesem Lab lernst du die Arrays in C++. Du wirst lernen, wie Arrays definiert und initialisiert werden, und wie Arrayfunktionen verwendet werden.

Inhaltsvorschau

Arrays werden üblicherweise verwendet, um Daten vom gleichen Typ zu speichern. Sie sind effizient, kompakt und leicht zugänglich. In Kombination mit Schleifen sind die Operationen für die Elemente in einem Array ziemlich einfach.

Um ein Array zu erstellen, musst du die Länge (oder Größe) des Arrays im Voraus kennen und entsprechend zuweisen. Einmal ein Array erstellt wurde, ist seine Länge fest und kann nicht geändert werden.

Arraydeklaration und Verwendung

Angenommen, du möchtest den Durchschnitt der Noten einer Klasse von 30 Schülern berechnen. Natürlich willst du nicht 30 Variablen erstellen: mark1, mark2,..., mark30. Stattdessen könntest du eine einzelne Variable verwenden, ein sogenanntes Array, mit 30 Elementen.

Ein Array ist eine Liste von Elementen vom gleichen Typ, identifiziert durch eckige Klammern [ ]. Um ein Array zu verwenden, musst du das Array mit drei Dingen deklarieren: einem Namen, einem Typ und einer Dimension (oder Größe, oder Länge). Wir empfehlen, für Arrays einen Pluralnamen zu verwenden, z.B. marks, rows, numbers. Beispielsweise:

int marks[5];        // Deklariere ein int-Array namens marks mit 5 Elementen
double numbers[10];  // Deklariere ein double-Array mit 10 Elementen
const int SIZE = 9;
float temps[SIZE];   // Verwende const int als Arraylänge

// Einige Compiler unterstützen eine Variable als Arraylänge, z.B.
int size;
cout << "Geben Sie die Länge des Arrays ein: ";
cin >> size;
float values[size];

Bemerkung: In C++ sind die Werte der Elemente nach der Deklaration unbestimmt.

Du kannst das Array auch während der Deklaration mit einer komma-getrennten Liste von Werten initialisieren, wie folgt:

// Deklariere und initialisiere ein int-Array mit 3 Elementen
int numbers[3] = {11, 33, 44};
// Wenn die Länge weggelassen wird, zählt der Compiler die Elemente
int numbers[] = {11, 33, 44};
// Die Anzahl der Elemente bei der Initialisierung muss gleich oder kleiner als die Länge sein
int numbers[5] = {11, 33, 44};  // Die restlichen Elemente sind 0. Verwirrend! Mach das nicht
int numbers[2] = {11, 33, 44};  // FEHLER: zu viele Initialisierer

// Verwende {0} oder {} um alle Elemente auf 0 zu initialisieren
int numbers[5] = {0};  // Erstes Element auf 0, die anderen auch auf 0
int numbers[5] = {};   // Alle Elemente auch auf 0

/* Teste die lokale Arrayinitialisierung */
#include <iostream>
using namespace std;

int main() {
   int const SIZE = 5;

   int a1[SIZE];   // Nicht initialisiert
   for (int i = 0; i < SIZE; ++i) cout << a1[i] << " ";
   cout << endl;   //?????

   int a2[SIZE] = {21, 22, 23, 24, 25}; // Alle Elemente initialisiert
   for (int i = 0; i < SIZE; ++i) cout << a2[i] << " ";
   cout << endl;   // 21 22 23 24 25

   int a3[] = {31, 32, 33, 34, 35};   // Größe aus den Initialisierungswerten abgeleitet
   int a3Size = sizeof(a3)/sizeof(int);
   cout << "Größe ist " << a3Size << endl;   // 5
   for (int i = 0; i < a3Size; ++i) cout << a3[i] << " ";
   cout << endl;   // 31 32 33 34 35

   int a4[SIZE] = {41, 42};  // Die führenden Elemente werden initialisiert, die anderen auf 0
   for (int i = 0; i < SIZE; ++i) cout << a4[i] << " ";
   cout << endl;   // 41 42 0 0 0

   int a5[SIZE] = {0};  // Erstes Element auf 0, die anderen auch auf 0
   for (int i = 0; i < SIZE; ++i) cout << a5[i] << " ";
   cout << endl;   // 0 0 0 0 0

   int a6[SIZE] = {};   // Alle Elemente auch auf 0
   for (int i = 0; i < SIZE; ++i) cout << a6[i] << " ";
   cout << endl;   // 0 0 0 0 0

   for (int i=0;i<5;i++){
       // Weise jedem Element des Arrays einen Wert zu, wie folgt
       a6[i] = i;
       cout << a6[i] << " ";
   }
}

Ausgabe:

6299128 0 485160213 32595 0 ## einige unerwartete Werte
21 22 23 24 25
Größe ist 5
31 32 33 34 35
41 42 0 0 0
0 0 0 0 0
0 0 0 0 0
0 1 2 3 4

Du kannst die Arraylänge mit dem Ausdruck sizeof(arrayName)/sizeof(arrayName[0]) finden, wobei sizeof(arrayName) die Gesamtzahl der Bytes des Arrays zurückgibt und sizeof(arrayName[0]) die Anzahl der Bytes des ersten Elements zurückgibt.

Array und Schleife

Arrays arbeiten eng mit Schleifen zusammen. Du kannst alle Elemente eines Arrays über eine Schleife verarbeiten. C++11 führt eine range-basierte For-Schleife (oder For-each-Schleife) ein, um durch ein Array zu iterieren, z.B.

/* Testing For-each loop */
#include <iostream>
using namespace std;

int main() {
   int numbers[] = {11, 22, 33, 44, 55};

   // Für jedes Element namens number des Arrays numbers - nur lesend
   for (int number : numbers) {
      cout << number << " ";
   }

   // Um die Elemente zu modifizieren, muss auf Referenz (&) zugegriffen werden
   for (int &number : numbers) {
      number = 99;
   }

   for (int number : numbers) {
      cout << number << endl;
   }
   return 0;
}

Ausgabe:

11 22 33 44 55
99 99 99 99 99

Mehrdimensionale Arrays

Beispielsweise:

int[2][3] = { {11, 22, 33}, {44, 55, 66} };

/* Test Multi-dimensional Array */
#include <iostream>
using namespace std;
void printArray(const int[][3], int);

int main() {
   int myArray[][3] = {{8, 2, 4}, {7, 5, 2}}; // 2x3 initialisiert
                 // Nur der erste Index kann weggelassen und impliziert werden
   printArray(myArray, 2);
   return 0;
}

// Druckt die Inhalte eines Zeilen-x-3-Arrays (Spalten sind fix)
void printArray(const int array[][3], int rows) {
   for (int i = 0; i < rows; ++i) {
      for (int j = 0; j < 3; ++j) {
         cout << array[i][j] << " ";
      }
      cout << endl;
   }
}

Ausgabe:

8 2 4
7 5 2

Array von Zeichen

In C ist ein String ein char-Array, das durch ein NULL-Zeichen '\0' (ASCII-Code Hex 0) abgeschlossen wird. C++ stellt eine neue string-Klasse unter dem Header <string> zur Verfügung. Die ursprünglichen Strings in C werden als C-String (oder C-Style String oder Character String) bezeichnet. Du kannst einen C-String wie folgt zuweisen:

char message[256];     // Deklariere ein char-Array
                       // Kann einen C-String mit bis zu 255 Zeichen halten, abgeschlossen durch '\0'
char str1[] = "Hello"; // Deklariere und initialisiere mit einem "String-Literal".
                       // Die Länge des Arrays ist die Anzahl der Zeichen + 1 (für '\0').
char str1char[] = {'H', 'e', 'l', 'l', 'o', '\0'};  // Wie oben
char str2[256] = "Hello";  // Die Länge des Arrays ist 256, um einen kleineren String zu speichern.

Für Einsteiger ist es ratsam, C-Strings zu vermeiden. Verwende die C++-string (im Header <string>), wie zuvor besprochen.

Du kannst cin und cout verwenden, um C-Strings zu verarbeiten.

• cin << liest einen String, der durch Leerzeichen begrenzt ist;
• cin.getline(*var*, *size*) liest einen String in var bis zum Zeilenumbruch, maximal bis zur Länge size-1, und verwirft den Zeilenumbruch (ersetzt durch '\0'). Die *size* entspricht typischerweise der Länge des C-String-Arrays.
• cin.get(*var*, *size*) liest einen String bis zum Zeilenumbruch, lässt den Zeilenumbruch jedoch im Eingabepuffer.
• cin.get(), ohne Argument, liest das nächste Zeichen.

/* Test C-string */
#include <iostream>
using namespace std;

int main() {
   char msg[256]; // Speichert einen String mit bis zu 255 Zeichen (abgeschlossen durch '\0')

   cout << "Geben Sie eine Nachricht ein (mit Leerzeichen)" << endl;
   cin.getline(msg, 256);  // Liest bis zu 255 Zeichen in msg
   cout << msg << endl;

   // Zugriff über null-terminiertes Zeichenarray
   for (int i = 0; msg[i]!= '\0'; ++i) {
      cout << msg[i];
   }
   cout << endl;

   cout << "Geben Sie ein Wort ein (ohne Leerzeichen)" << endl;
   cin >> msg;
   cout << msg << endl;

   // Zugriff über null-terminiertes Zeichenarray
   for (int i = 0; msg[i]!= '\0'; ++i) {
      cout << msg[i];
   }
   cout << endl;
   return 0;
}

Ausgabe:

Geben Sie eine Nachricht ein (mit Leerzeichen)
hello, how are you?
hello, how are you?
hello, how are you?
Geben Sie ein Wort ein (ohne Leerzeichen)
helloworld
helloworld
helloworld

Zusammenfassung

C/C++ führt keine Index-Grenzenprüfung für Arrays durch. Mit anderen Worten, wenn der Index außerhalb der Grenzen des Arrays liegt, wird keine Warnung/Fehlermeldung ausgegeben. Dennoch musst du die Länge abschätzen und einen Obergrenzwert zuweisen. Dies ist wahrscheinlich der größte Nachteil bei der Verwendung eines Arrays. C++ hat eine vector-Vorlagenklasse (und C++11 hat eine array-Vorlagenklasse hinzugefügt), die dynamisch vergrößerbare Arrays unterstützt.