Arrays und Strings in C++ manipulieren

Einführung

In diesem Lab werden Sie lernen, wie Sie Arrays und Strings in C++ manipulieren können. Das Lab behandelt eine Reihe von Themen, darunter das Erstellen und Initialisieren von eindimensionalen Arrays, das Zugreifen auf und Modifizieren von Array-Elementen, die Implementierung von zweidimensionalen Arrays, die Arbeit mit C-Strings und der String-Klasse, das Sortieren von Array-Elementen, die Durchführung einer linearen Suche und die Verarbeitung von String-Eingaben mit getline(). Durch diese praktischen Übungen werden Sie ein solides Verständnis der grundlegenden Array- und String-Operationen in der C++-Programmierung entwickeln.

Erstellen und Initialisieren von eindimensionalen Arrays

In diesem Schritt werden Sie lernen, wie Sie eindimensionale Arrays in C++ erstellen und initialisieren. Arrays sind grundlegende Datenstrukturen, die es Ihnen ermöglichen, mehrere Elemente desselben Typs an einem zusammenhängenden Speicherort zu speichern.

Öffnen Sie die WebIDE und erstellen Sie eine neue Datei namens arrays_intro.cpp im Verzeichnis ~/project. Wir werden verschiedene Methoden zur Initialisierung von Arrays untersuchen.

touch ~/project/arrays_intro.cpp

Fügen Sie den folgenden Code zur Datei arrays_intro.cpp hinzu:

#include <iostream>

int main() {
    // Methode 1: Deklarieren und initialisieren eines Arrays mit einer bestimmten Größe
    int numbers[5] = {10, 20, 30, 40, 50};

    // Methode 2: Lassen Sie den Compiler die Array-Größe bestimmen
    int scores[] = {85, 92, 78, 95, 88};

    // Methode 3: Initialisieren des Arrays mit dem Standardwert Null
    int zeros[6] = {0};

    // Methode 4: Erstellen eines Arrays und spätere Initialisierung
    int temperatures[4];
    temperatures[0] = 72;
    temperatures[1] = 68;
    temperatures[2] = 75;
    temperatures[3] = 80;

    // Ausgabe der Array-Elemente
    std::cout << "Erste Methode - numbers-Array:" << std::endl;
    for (int i = 0; i < 5; i++) {
        std::cout << "Element " << i << ": " << numbers[i] << std::endl;
    }

    return 0;
}

Lassen Sie uns die Array-Initialisierung analysieren:

int numbers[5] = {10, 20, 30, 40, 50};: Definieren Sie explizit die Array-Größe und initialisieren Sie alle Elemente.
int scores[] = {85, 92, 78, 95, 88};: Lassen Sie den Compiler die Array-Größe bestimmen.
int zeros[6] = {0};: Initialisieren Sie alle Elemente mit Null.
Weisen Sie manuell Werte mithilfe des Index zu: temperatures[index] = value

Kompilieren und führen Sie das Programm aus:

g++ arrays_intro.cpp -o arrays_intro
./arrays_intro

Beispielausgabe:

Erste Methode - numbers-Array:
Element 0: 10
Element 1: 20
Element 2: 30
Element 3: 40
Element 4: 50

Wichtige Punkte zu Arrays:

Arrays haben eine feste Größe, sobald sie deklariert sind.
Die Array-Indizierung beginnt bei 0.
Sie können Arrays auf verschiedene Weise initialisieren.
Stellen Sie immer sicher, dass Sie die Array-Grenzen nicht überschreiten.

Zugriff auf und Modifikation von Array-Elementen über den Index

In diesem Schritt werden Sie lernen, wie Sie in C++ auf Array-Elemente zugreifen und diese über ihren Index modifizieren können. Basierend auf dem vorherigen Schritt der Array-Initialisierung werden wir untersuchen, wie man mit einzelnen Array-Elementen interagiert.

Öffnen Sie die WebIDE und erstellen Sie eine neue Datei namens array_indexing.cpp im Verzeichnis ~/project:

touch ~/project/array_indexing.cpp

Fügen Sie den folgenden Code zur Datei array_indexing.cpp hinzu:

#include <iostream>

int main() {
    // Erstellen eines Arrays mit Schülerleistungen
    int scores[5] = {85, 92, 78, 95, 88};

    // Zugriff auf Array-Elemente über den Index
    std::cout << "Punktzahl des ersten Schülers: " << scores[0] << std::endl;
    std::cout << "Punktzahl des dritten Schülers: " << scores[2] << std::endl;

    // Modifikation von Array-Elementen
    std::cout << "Ursprüngliche Punktzahl des zweiten Schülers: " << scores[1] << std::endl;
    scores[1] = 96; // Aktualisieren der Punktzahl des zweiten Schülers
    std::cout << "Aktualisierte Punktzahl des zweiten Schülers: " << scores[1] << std::endl;

    // Berechnung der Summe der Array-Elemente
    int total_score = 0;
    for (int i = 0; i < 5; i++) {
        total_score += scores[i];
    }
    std::cout << "Gesamtpunktzahl der Klasse: " << total_score << std::endl;

    // Berechnung der Durchschnittspunktzahl
    double average_score = static_cast<double>(total_score) / 5;
    std::cout << "Durchschnittliche Punktzahl der Klasse: " << average_score << std::endl;

    return 0;
}

Wichtige Punkte zur Array-Indizierung:

Array-Indizes beginnen bei 0.
Verwenden Sie eckige Klammern [], um auf Elemente zuzugreifen.
Sie können Elemente über ihren Index lesen und modifizieren.
Achten Sie darauf, nicht auf Indizes außerhalb der Array-Grenzen zuzugreifen.

Kompilieren und führen Sie das Programm aus:

g++ array_indexing.cpp -o array_indexing
./array_indexing

Beispielausgabe:

Punktzahl des ersten Schülers: 85
Punktzahl des dritten Schülers: 78
Ursprüngliche Punktzahl des zweiten Schülers: 92
Aktualisierte Punktzahl des zweiten Schülers: 96
Gesamtpunktzahl der Klasse: 442
Durchschnittliche Punktzahl der Klasse: 88.4

Wichtige Regeln zur Indizierung:

Das erste Element befindet sich am Index 0.
Das letzte Element befindet sich am Index (Arraygröße - 1).
Der Zugriff auf einen Index außerhalb des Array-Bereichs führt zu undefiniertem Verhalten.

Implementierung von zweidimensionalen Arrays für Matrizen

In diesem Schritt werden Sie lernen, wie Sie in C++ zweidimensionale Arrays erstellen und damit arbeiten können. Zweidimensionale Arrays sind wie Tabellen oder Matrizen mit Zeilen und Spalten, die es Ihnen ermöglichen, Daten in einer gitterartigen Struktur zu speichern und zu manipulieren.

Öffnen Sie die WebIDE und erstellen Sie eine neue Datei namens matrix_arrays.cpp im Verzeichnis ~/project:

touch ~/project/matrix_arrays.cpp

Fügen Sie den folgenden Code zur Datei matrix_arrays.cpp hinzu:

#include <iostream>

int main() {
    // Methode 1: Deklarieren und initialisieren einer 3x3-Matrix
    int matrix[3][3] = {
        {1, 2, 3},
        {4, 5, 6},
        {7, 8, 9}
    };

    // Methode 2: Deklarieren der Matrix und spätere Initialisierung
    int grades[2][4];
    grades[0][0] = 85;
    grades[0][1] = 92;
    grades[0][2] = 78;
    grades[0][3] = 95;
    grades[1][0] = 88;
    grades[1][1] = 90;
    grades[1][2] = 82;
    grades[1][3] = 87;

    // Ausgabe der ersten Matrix
    std::cout << "Erste Matrix:" << std::endl;
    for (int row = 0; row < 3; row++) {
        for (int col = 0; col < 3; col++) {
            std::cout << matrix[row][col] << " ";
        }
        std::cout << std::endl;
    }

    // Ausgabe der Notenmatrix
    std::cout << "\nNotenmatrix:" << std::endl;
    for (int row = 0; row < 2; row++) {
        for (int col = 0; col < 4; col++) {
            std::cout << grades[row][col] << " ";
        }
        std::cout << std::endl;
    }

    return 0;
}

Wichtige Punkte zu zweidimensionalen Arrays:

Verwenden Sie zwei Indizes, um auf Elemente zuzugreifen: array[row][column]
Der erste Index repräsentiert die Zeile, der zweite Index repräsentiert die Spalte.
Sie können auf verschiedene Weise initialisiert werden.
Normalerweise werden geschachtelte Schleifen verwendet, um durch die Zeilen und Spalten zu iterieren.

Kompilieren und führen Sie das Programm aus:

g++ matrix_arrays.cpp -o matrix_arrays
./matrix_arrays

Beispielausgabe:

Erste Matrix:
1 2 3
4 5 6
7 8 9

Notenmatrix:
85 92 78 95
88 90 82 87

Wichtige Konzepte zu zweidimensionalen Arrays:

Arrays können mehr als zwei Dimensionen haben.
Jede Zeile kann eine unterschiedliche Anzahl von Spalten haben.
Achten Sie immer auf die Array-Grenzen, um Fehler zu vermeiden.

Initialisierung von C-Strings mit Null-Terminator

In diesem Schritt werden Sie über C-Strings und die Wichtigkeit des Null-Terminators in C++ lernen. C-Strings sind Zeichenarrays, die mit einem speziellen '\0'-Zeichen enden, um das Ende des Strings zu markieren.

Öffnen Sie die WebIDE und erstellen Sie eine neue Datei namens c_style_strings.cpp im Verzeichnis ~/project:

touch ~/project/c_style_strings.cpp

Fügen Sie den folgenden Code zur Datei c_style_strings.cpp hinzu:

#include <iostream>
#include <cstring>

int main() {
    // Methode 1: Initialisierung eines Strings mit explizitem Null-Terminator
    char greeting[6] = {'H', 'e', 'l', 'l', 'o', '\0'};
    std::cout << "Begrüßung: " << greeting << std::endl;

    // Methode 2: Initialisierung als String-Literal (fügt automatisch Null-Terminator hinzu)
    char name[] = "John Doe";
    std::cout << "Name: " << name << std::endl;

    // Methode 3: Deklaration mit fester Größe und Initialisierung
    char message[20] = "Welcome to C++!";
    std::cout << "Nachricht: " << message << std::endl;

    // Demonstration der String-Länge
    std::cout << "Länge des Namens: " << strlen(name) << std::endl;

    // Manuelle Berechnung der String-Länge
    int length = 0;
    while (name[length]!= '\0') {
        length++;
    }
    std::cout << "Manuelle Länge des Namens: " << length << std::endl;

    return 0;
}

Wichtige Punkte zu C-Strings:

Der Null-Terminator '\0' markiert das Ende des Strings.
Reservieren Sie immer ein zusätzliches Zeichen für den Null-Terminator.
String-Literale fügen automatisch den Null-Terminator hinzu.
Die Funktion strlen() zählt die Zeichen vor dem Null-Terminator.

Kompilieren und führen Sie das Programm aus:

g++ c_style_strings.cpp -o c_style_strings
./c_style_strings

Beispielausgabe:

Begrüßung: Hello
Name: John Doe
Nachricht: Welcome to C++!
Länge des Namens: 8
Manuelle Länge des Namens: 8

Wichtige Konzepte zur String-Initialisierung:

Der Null-Terminator ist für String-Operationen von entscheidender Bedeutung.
Stellen Sie immer sicher, dass genug Platz für den Null-Terminator vorhanden ist.
Achten Sie auf die Größe des String-Puffers, um Überläufe zu vermeiden.

Verwenden von Methoden der String-Klasse (length, substr, find)

In diesem Schritt werden Sie über die leistungsstarken Methoden der String-Klasse in C++ lernen, die die Manipulation von Strings einfacher und intuitiver machen. Wir werden Schlüsselmethoden wie length(), substr() und find() untersuchen.

Öffnen Sie die WebIDE und erstellen Sie eine neue Datei namens string_methods.cpp im Verzeichnis ~/project:

touch ~/project/string_methods.cpp

Fügen Sie den folgenden Code zur Datei string_methods.cpp hinzu:

#include <iostream>
#include <string>

int main() {
    // Erstellen eines Strings
    std::string message = "Hello, C++ Programming!";

    // Verwenden der length()-Methode
    std::cout << "Stringlänge: " << message.length() << std::endl;

    // Verwenden der substr()-Methode
    std::cout << "Erste 5 Zeichen: " << message.substr(0, 5) << std::endl;
    std::cout << "Teilstring ab Index 7: " << message.substr(7) << std::endl;

    // Verwenden der find()-Methode
    std::string search_word = "Programming";
    size_t position = message.find(search_word);

    if (position!= std::string::npos) {
        std::cout << "'" << search_word << "' gefunden an Index: " << position << std::endl;
    } else {
        std::cout << "Wort nicht gefunden" << std::endl;
    }

    // Zusätzliches Beispiel für find()
    std::string email = "user@example.com";
    size_t at_symbol = email.find('@');
    size_t dot_symbol = email.find('.');

    std::cout << "Benutzername: " << email.substr(0, at_symbol) << std::endl;
    std::cout << "Domain: " << email.substr(at_symbol + 1, dot_symbol - at_symbol - 1) << std::endl;

    return 0;
}

Wichtige Punkte zu den Methoden der String-Klasse:

length(): Gibt die Anzahl der Zeichen im String zurück.
substr(): Extrahiert einen Teil des Strings.
- Das erste Argument ist der Startindex.
- Das zweite Argument (optional) ist die Länge des Teilstrings.
find(): Sucht nach einem Teilstring oder einem Zeichen.
- Gibt den Index der ersten Vorkommnis zurück.
- Gibt std::string::npos zurück, wenn nichts gefunden wird.

Kompilieren und führen Sie das Programm aus:

g++ string_methods.cpp -o string_methods
./string_methods

Beispielausgabe:

Stringlänge: 23
Erste 5 Zeichen: Hello
Teilstring ab Index 7: C++ Programming!
'Programming' gefunden an Index: 11
Benutzername: user
Domain: example

Wichtige Konzepte zu String-Methoden:

String-Methoden bieten leistungsstarke Textmanipulation.
Die Indizierung beginnt bei 0.
Prüfen Sie immer die Rückgabewerte, um potenzielle Fehler zu behandeln.

Konvertierung zwischen C-Strings und der String-Klasse

In diesem Schritt werden Sie lernen, wie Sie zwischen C-Strings und der C++-String-Klasse konvertieren können. Diese Konvertierungen sind essentiell, wenn Sie mit verschiedenen String-Darstellungen in C++ arbeiten.

Öffnen Sie die WebIDE und erstellen Sie eine neue Datei namens string_conversion.cpp im Verzeichnis ~/project:

touch ~/project/string_conversion.cpp

Fügen Sie den folgenden Code zur Datei string_conversion.cpp hinzu:

#include <iostream>
#include <string>
#include <cstring>

int main() {
    // C-String in C++-String konvertieren
    const char* c_style_str = "Hello, C++ World!";
    std::string cpp_string(c_style_str);
    std::cout << "C++-String: " << cpp_string << std::endl;

    // C++-String in C-String konvertieren
    std::string message = "Converting strings";
    const char* c_str = message.c_str();
    std::cout << "C-String: " << c_str << std::endl;

    // Manuelle Konvertierung mit strcpy
    char buffer[50];
    strcpy(buffer, message.c_str());
    std::cout << "In Puffer kopiert: " << buffer << std::endl;

    // Vergleich der String-Längen
    std::cout << "Länge des C++-Strings: " << message.length() << std::endl;
    std::cout << "Länge des C-Strings: " << strlen(c_str) << std::endl;

    return 0;
}

Wichtige Konvertierungsmethoden:

std::string(c_style_str): Konvertiert einen C-String in einen C++-String.
.c_str(): Konvertiert einen C++-String in einen C-String.
strcpy(): Kopiert manuell einen String in ein Zeichenarray.

Kompilieren und führen Sie das Programm aus:

g++ string_conversion.cpp -o string_conversion
./string_conversion

Beispielausgabe:

C++-String: Hello, C++ World!
C-String: Converting strings
In Puffer kopiert: Converting strings
Länge des C++-Strings: 18
Länge des C-Strings: 18

Wichtige Konvertierungskonzepte:

Verwenden Sie .c_str(), um einen const char* aus einem C++-String zu erhalten.
Achten Sie auf die Puffergröße bei der Konvertierung.
strlen() funktioniert mit C-Strings.
.length() funktioniert mit C++-Strings.

Sortieren von Array-Elementen mit Bubble Sort

In diesem Schritt werden Sie lernen, wie Sie den Bubble-Sort-Algorithmus implementieren, um Array-Elemente in C++ zu sortieren. Bubble Sort ist eine einfache Sortiermethode, die wiederholt durch die Liste geht, benachbarte Elemente vergleicht und sie vertauscht, wenn sie in der falschen Reihenfolge sind.

Öffnen Sie die WebIDE und erstellen Sie eine neue Datei namens bubble_sort.cpp im Verzeichnis ~/project:

touch ~/project/bubble_sort.cpp

Fügen Sie den folgenden Code zur Datei bubble_sort.cpp hinzu:

#include <iostream>

int main() {
    // Initialisieren eines unsortierten Arrays
    int numbers[5] = {64, 34, 25, 12, 22};
    int size = 5;

    // Ausgabe des ursprünglichen Arrays
    std::cout << "Ursprüngliches Array: ";
    for (int i = 0; i < size; i++) {
        std::cout << numbers[i] << " ";
    }
    std::cout << std::endl;

    // Implementierung von Bubble Sort
    for (int i = 0; i < size - 1; i++) {
        for (int j = 0; j < size - i - 1; j++) {
            // Vergleich benachbarter Elemente
            if (numbers[j] > numbers[j + 1]) {
                // Vertauschen der Elemente
                int temp = numbers[j];
                numbers[j] = numbers[j + 1];
                numbers[j + 1] = temp;
            }
        }
    }

    // Ausgabe des sortierten Arrays
    std::cout << "Sortiertes Array: ";
    for (int i = 0; i < size; i++) {
        std::cout << numbers[i] << " ";
    }
    std::cout << std::endl;

    return 0;
}

Wichtige Konzepte von Bubble Sort:

Vergleicht benachbarte Elemente.
Vertauscht Elemente, wenn sie in der falschen Reihenfolge sind.
Wiederholt Durchläufe durch das Array, bis es sortiert ist.
Zeitkomplexität: O(n²)

Kompilieren und führen Sie das Programm aus:

g++ bubble_sort.cpp -o bubble_sort
./bubble_sort

Beispielausgabe:

Ursprüngliches Array: 64 34 25 12 22
Sortiertes Array: 12 22 25 34 64

Wichtige Hinweise zur Sortierung:

Bubble Sort ist einfach, aber ineffizient für große Arrays.
Gut für Bildungszwecke.
Es gibt effizientere Sortieralgorithmen für reale Anwendungen.

Implementierung der linearen Suche in Arrays

In diesem Schritt werden Sie lernen, wie Sie einen Algorithmus für die lineare Suche in C++ implementieren. Die lineare Suche ist eine einfache Methode, um ein Element in einem Array zu finden, indem jedes Element nacheinander überprüft wird, bis das gesuchte Element gefunden oder das Ende des Arrays erreicht ist.

Öffnen Sie die WebIDE und erstellen Sie eine neue Datei namens linear_search.cpp im Verzeichnis ~/project:

touch ~/project/linear_search.cpp

Fügen Sie den folgenden Code zur Datei linear_search.cpp hinzu:

#include <iostream>

int linearSearch(int arr[], int size, int target) {
    // Iterieren durch jedes Element im Array
    for (int i = 0; i < size; i++) {
        // Überprüfen, ob das aktuelle Element mit dem Ziel übereinstimmt
        if (arr[i] == target) {
            return i;  // Rückgabe des Indexes, wenn gefunden
        }
    }
    return -1;  // Rückgabe von -1, wenn das Ziel nicht gefunden wird
}

int main() {
    // Erstellen eines Arrays mit Schülerleistungen
    int scores[] = {85, 92, 78, 95, 88, 76, 90};
    int size = sizeof(scores) / sizeof(scores[0]);

    // Zielnote, nach der gesucht wird
    int targetScore = 78;

    // Durchführen der linearen Suche
    int result = linearSearch(scores, size, targetScore);

    // Anzeigen der Suchergebnisse
    if (result!= -1) {
        std::cout << "Zielnote " << targetScore
                  << " an Index " << result << " gefunden" << std::endl;
    } else {
        std::cout << "Zielnote " << targetScore
                  << " nicht im Array gefunden" << std::endl;
    }

    // Versuch einer anderen Suche
    int missingScore = 100;
    result = linearSearch(scores, size, missingScore);

    if (result!= -1) {
        std::cout << "Note " << missingScore
                  << " an Index " << result << " gefunden" << std::endl;
    } else {
        std::cout << "Note " << missingScore
                  << " nicht im Array gefunden" << std::endl;
    }

    return 0;
}

Wichtige Konzepte der linearen Suche:

Überprüft jedes Array-Element nacheinander.
Gibt den Index des gesuchten Elements zurück, wenn es gefunden wird.
Gibt -1 zurück, wenn das gesuchte Element nicht im Array ist.
Zeitkomplexität: O(n) – lineare Zeit.
Einfach und funktioniert für unsortierte Arrays.

Kompilieren und führen Sie das Programm aus:

g++ linear_search.cpp -o linear_search
./linear_search

Beispielausgabe:

Zielnote 78 an Index 2 gefunden
Note 100 nicht im Array gefunden

Wichtige Hinweise zur Suche:

Die lineare Suche ist einfach, aber ineffizient für große Arrays.
Geeignet für kleine Arrays oder unsortierte Sammlungen.
Es gibt effizientere Suchalgorithmen für sortierte Arrays.

Verarbeitung von String-Eingaben mit getline()

In diesem Schritt werden Sie lernen, wie Sie getline() verwenden, um vollständige Textzeilen als Eingabe in C++ zu lesen. Im Gegensatz zu cin >> kann getline() Strings mit Leerzeichen lesen und komplexere Eingabeszenarien verarbeiten.

Öffnen Sie die WebIDE und erstellen Sie eine neue Datei namens getline_input.cpp im Verzeichnis ~/project:

touch ~/project/getline_input.cpp

Fügen Sie den folgenden Code zur Datei getline_input.cpp hinzu:

#include <iostream>
#include <string>

int main() {
    // Deklarieren eines Strings zur Speicherung der Eingabe
    std::string fullName;
    std::string address;

    // Aufforderung zur Eingabe des Vornamens und Nachnamens
    std::cout << "Geben Sie Ihren Vornamen und Nachnamen ein: ";
    std::getline(std::cin, fullName);

    // Aufforderung zur Eingabe der Adresse
    std::cout << "Geben Sie Ihre vollständige Adresse ein: ";
    std::getline(std::cin, address);

    // Anzeigen der Eingabe mit zusätzlichen Informationen
    std::cout << "\n--- Benutzerinformationen ---" << std::endl;
    std::cout << "Name: " << fullName << std::endl;
    std::cout << "Adresse: " << address << std::endl;

    // Demonstration des Lesens mehrerer Zeilen
    std::string multiLineText;
    std::cout << "\nGeben Sie eine mehrzeilige Beschreibung ein (drücken Sie Ctrl+D, um zu beenden):" << std::endl;

    std::string line;
    while (std::getline(std::cin, line)) {
        multiLineText += line + "\n";
    }

    std::cout << "\nIhre Beschreibung:" << std::endl;
    std::cout << multiLineText;

    return 0;
}

Wichtige Konzepte von getline():

Liest eine gesamte Textzeile, einschließlich Leerzeichen.
Syntax: std::getline(Eingabestream, Stringvariable)
Kann mehrere Zeilen Eingabe lesen.
Verarbeitet komplexe Eingaben mit Leerzeichen.
Nützlich zum Lesen von Vornamen und Nachnamen, Adressen usw.

Kompilieren Sie das Programm:

g++ getline_input.cpp -o getline_input
./getline_input

Beispielinteraktion:

Geben Sie Ihren Vornamen und Nachnamen ein: John Michael Smith
Geben Sie Ihre vollständige Adresse ein: 123 Main Street, Anytown, USA

--- Benutzerinformationen ---
Name: John Michael Smith
Adresse: 123 Main Street, Anytown, USA

Geben Sie eine mehrzeilige Beschreibung ein (drücken Sie Ctrl+D, um zu beenden):
This is a sample
multi-line description
with several lines of text.

Ihre Beschreibung:
This is a sample
multi-line description
with several lines of text.

Wichtige Hinweise zur Eingabeverarbeitung:

getline() liest bis zum Zeilenumbruchzeichen.
Nützlich zum Erfassen vollständiger Texteingaben.
Kann mit anderen Eingabemethoden kombiniert werden.

Zusammenfassung

In diesem Lab werden Sie lernen, wie Sie eindimensionale Arrays in C++ erstellen und initialisieren, Array-Elemente über Indizes zugreifen und ändern, zweidimensionale Arrays für Matrizen implementieren, C-Strings mit Null-Terminator initialisieren, Methoden der String-Klasse verwenden, zwischen C-Strings und der String-Klasse konvertieren, Array-Elemente mit Bubble Sort sortieren, lineare Suche in Arrays implementieren und String-Eingaben mit getline() verarbeiten.

Sie werden verschiedene Möglichkeiten zur Initialisierung von Arrays erkunden, darunter die Angabe der Größe und die Initialisierung aller Elemente, die automatische Bestimmung der Größe durch den Compiler, die Initialisierung aller Elemente auf Null und die manuelle Zuweisung von Werten über Indizes. Sie werden auch lernen, wie Sie über Indizes auf Array-Elemente zugreifen und diese ändern sowie wie Sie Array-Grenzen behandeln, um Fehler zu vermeiden. Darüber hinaus werden Sie mit zweidimensionalen Arrays, C-Strings und der String-Klasse arbeiten und lernen, wie Sie zwischen ihnen konvertieren und verschiedene Operationen ausführen.