Verwenden von STL-Komponenten in C++

Einführung

In diesem Lab lernen Sie, wie Sie verschiedene Komponenten der C++ Standard Template Library (STL) verwenden, um Datenstrukturen wie Vektoren, Listen, Maps, Sets und mehr zu erstellen und zu manipulieren. Sie werden die grundlegenden Operationen dieser STL-Container erkunden, einschließlich dem Hinzufügen, Entfernen und Durchlaufen von Elementen. Darüber hinaus werden Sie entdecken, wie Sie STL-Algorithmen nutzen können, um Daten in diesen Containern zu sortieren, zu suchen und zu verarbeiten. Am Ende dieses Labs werden Sie ein solides Verständnis davon haben, wie Sie die Stärke und Flexibilität der C++ STL nutzen können, um effiziente und robuste Anwendungen zu entwickeln.

Erstellen und Manipulieren eines Vektor-Containers

In diesem Schritt lernen Sie über den C++ Standard Template Library (STL) Vektor-Container, der ein dynamisches Array ist, dessen Größe sich vergrößern und verkleinern kann. Vektoren sind unglaublich nützlich für das Speichern und Manipulieren von Elementesammlungen.

Öffnen Sie zunächst die WebIDE und erstellen Sie eine neue Datei namens vector_demo.cpp im Verzeichnis ~/project. Wir werden die grundlegenden Operationen von Vektoren Schritt für Schritt erkunden.

touch ~/project/vector_demo.cpp

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

#include <iostream>
#include <vector>

int main() {
    // Create an empty vector of integers
    std::vector<int> numbers;

    // Add elements to the vector using push_back()
    numbers.push_back(10);
    numbers.push_back(20);
    numbers.push_back(30);

    // Print the size of the vector
    std::cout << "Vector size: " << numbers.size() << std::endl;

    // Access elements using index
    std::cout << "First element: " << numbers[0] << std::endl;
    std::cout << "Second element: " << numbers[1] << std::endl;

    // Iterate through the vector using a range-based for loop
    std::cout << "All elements: ";
    for (int num : numbers) {
        std::cout << num << " ";
    }
    std::cout << std::endl;

    // Remove the last element
    numbers.pop_back();

    // Check the new size after removing an element
    std::cout << "Vector size after pop_back(): " << numbers.size() << std::endl;

    return 0;
}

Kompilieren und führen Sie das Programm aus:

g++ vector_demo.cpp -o vector_demo
./vector_demo

Beispielausgabe:

Vector size: 3
First element: 10
Second element: 20
All elements: 10 20 30
Vector size after pop_back(): 2

Wichtige Punkte über Vektoren:

• Verwenden Sie #include <vector>, um die Vektor-Bibliothek einzubinden
• std::vector<type> erstellt einen Vektor eines bestimmten Typs
• push_back() fügt Elemente am Ende des Vektors hinzu
• size() gibt die Anzahl der Elemente zurück
• Greifen Sie auf Elemente über den Index [] zu
• pop_back() entfernt das letzte Element
• Eine Bereichsbasierte for-Schleife ist eine einfache Möglichkeit, durch Vektoren zu iterieren

Verwendung von List für Operationen an verketteten Listen

In diesem Schritt lernen Sie über den C++ STL-Listen-Container (list container), der eine doppelt verkettete Liste implementiert. Listen bieten effiziente Einfüge- und Löschoperationen an jeder Position im Container.

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

touch ~/project/list_demo.cpp

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

#include <iostream>
#include <list>

int main() {
    // Create an empty list of integers
    std::list<int> numbers;

    // Add elements to the list
    numbers.push_back(10);    // Add to the end
    numbers.push_front(5);    // Add to the beginning
    numbers.push_back(20);

    // Print the list size
    std::cout << "List size: " << numbers.size() << std::endl;

    // Iterate through the list
    std::cout << "List elements: ";
    for (int num : numbers) {
        std::cout << num << " ";
    }
    std::cout << std::endl;

    // Remove elements
    numbers.pop_front();  // Remove first element
    numbers.pop_back();   // Remove last element

    // Insert an element at a specific position
    auto it = numbers.begin();
    numbers.insert(it, 15);

    // Print updated list
    std::cout << "Updated list: ";
    for (int num : numbers) {
        std::cout << num << " ";
    }
    std::cout << std::endl;

    // Check if list is empty
    std::cout << "Is list empty? "
              << (numbers.empty()? "Yes" : "No") << std::endl;

    return 0;
}

Kompilieren und führen Sie das Programm aus:

g++ list_demo.cpp -o list_demo
./list_demo

Beispielausgabe:

List size: 3
List elements: 5 10 20
Updated list: 15 10
Is list empty? No

Wichtige Punkte über Listen:

• Verwenden Sie #include <list>, um die Listen-Bibliothek einzubinden
• push_back() fügt Elemente am Ende hinzu
• push_front() fügt Elemente am Anfang hinzu
• pop_front() und pop_back() entfernen Elemente
• insert() ermöglicht das Hinzufügen von Elementen an einer bestimmten Position
• begin() gibt einen Iterator auf das erste Element zurück
• empty() prüft, ob die Liste leer ist

Implementierung von Schlüssel-Wert-Paaren mit Map

In diesem Schritt lernen Sie über den C++ STL-Map-Container (Map-Container), der Schlüssel-Wert-Paare in sortierter und eindeutiger Schlüsselreihenfolge speichert. Maps sind nützlich für das Erstellen von Wörterbüchern oder assoziativen Arrays.

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

touch ~/project/map_demo.cpp

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

#include <iostream>
#include <map>
#include <string>

int main() {
    // Create a map to store student names and their ages
    std::map<std::string, int> students;

    // Insert key-value pairs
    students["Alice"] = 20;
    students["Bob"] = 22;
    students["Charlie"] = 21;

    // Access values using keys
    std::cout << "Alice's age: " << students["Alice"] << std::endl;

    // Check if a key exists
    if (students.count("David") == 0) {
        std::cout << "David is not in the map" << std::endl;
    }

    // Iterate through the map
    std::cout << "All students:" << std::endl;
    for (const auto& student : students) {
        std::cout << student.first << ": " << student.second << std::endl;
    }

    // Remove a key-value pair
    students.erase("Bob");

    // Check the size of the map
    std::cout << "Number of students: " << students.size() << std::endl;

    return 0;
}

Kompilieren und führen Sie das Programm aus:

g++ map_demo.cpp -o map_demo
./map_demo

Beispielausgabe:

Alice's age: 20
David is not in the map
All students:
Alice: 20
Bob: 22
Charlie: 21
Number of students: 2

Wichtige Punkte über Maps:

• Verwenden Sie #include <map>, um die Map-Bibliothek einzubinden
• map<KeyType, ValueType> erstellt eine Map mit bestimmten Schlüssel- und Werttypen
• Greifen Sie auf Werte über eckige Klammern [] zu
• count() prüft, ob ein Schlüssel existiert
• Iterieren Sie durch Maps mit einer Bereichs-basierten for-Schleife
• erase() entfernt ein Schlüssel-Wert-Paar
• size() gibt die Anzahl der Elemente zurück

Speichern von eindeutigen Elementen mit Set

In diesem Schritt lernen Sie über den C++ STL-Set-Container (Set-Container), der eindeutige Elemente in sortierter Reihenfolge speichert. Sets verhindern automatisch doppelte Werte und halten die Elemente in einer bestimmten Reihenfolge.

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

touch ~/project/set_demo.cpp

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

#include <iostream>
#include <set>

int main() {
    // Create a set of integers
    std::set<int> numbers;

    // Insert elements
    numbers.insert(10);
    numbers.insert(20);
    numbers.insert(30);
    numbers.insert(10);  // Duplicate, will not be added

    // Print the size of the set
    std::cout << "Set size: " << numbers.size() << std::endl;

    // Iterate through the set
    std::cout << "Set elements: ";
    for (int num : numbers) {
        std::cout << num << " ";
    }
    std::cout << std::endl;

    // Check if an element exists
    if (numbers.count(20) > 0) {
        std::cout << "20 is in the set" << std::endl;
    }

    // Remove an element
    numbers.erase(20);

    // Check the size after removal
    std::cout << "Set size after removal: " << numbers.size() << std::endl;

    // Clear the set
    numbers.clear();

    // Check if the set is empty
    std::cout << "Is set empty? "
              << (numbers.empty()? "Yes" : "No") << std::endl;

    return 0;
}

Kompilieren und führen Sie das Programm aus:

g++ set_demo.cpp -o set_demo
./set_demo

Beispielausgabe:

Set size: 3
Set elements: 10 20 30
20 is in the set
Set size after removal: 2
Is set empty? Yes

Wichtige Punkte über Sets:

• Verwenden Sie #include <set>, um die Set-Bibliothek einzubinden
• set<type> erstellt ein Set von eindeutigen Elementen
• insert() fügt Elemente hinzu (Doppelte werden ignoriert)
• count() prüft die Existenz eines Elements
• erase() entfernt ein Element
• clear() entfernt alle Elemente
• empty() prüft, ob das Set leer ist
• Elemente werden automatisch sortiert

Sortieren von Elementen mit dem STL-Sortieralgorithmus

In diesem Schritt lernen Sie, wie Sie den STL-Sortieralgorithmus verwenden, um Elemente in aufsteigender oder absteigender Reihenfolge zu ordnen. Die <algorithm>-Bibliothek bietet leistungsstarke Sortierfunktionen für verschiedene Container.

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

touch ~/project/sort_demo.cpp

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

#include <iostream>
#include <vector>
#include <algorithm>

int main() {
    // Create a vector of integers
    std::vector<int> numbers = {5, 2, 8, 1, 9, 3};

    // Print original vector
    std::cout << "Original vector: ";
    for (int num : numbers) {
        std::cout << num << " ";
    }
    std::cout << std::endl;

    // Sort the vector in ascending order
    std::sort(numbers.begin(), numbers.end());

    // Print sorted vector
    std::cout << "Sorted vector (ascending): ";
    for (int num : numbers) {
        std::cout << num << " ";
    }
    std::cout << std::endl;

    // Sort the vector in descending order
    std::sort(numbers.begin(), numbers.end(), std::greater<int>());

    // Print vector sorted in descending order
    std::cout << "Sorted vector (descending): ";
    for (int num : numbers) {
        std::cout << num << " ";
    }
    std::cout << std::endl;

    return 0;
}

Kompilieren und führen Sie das Programm aus:

g++ sort_demo.cpp -o sort_demo
./sort_demo

Beispielausgabe:

Original vector: 5 2 8 1 9 3
Sorted vector (ascending): 1 2 3 5 8 9
Sorted vector (descending): 9 8 5 3 2 1

Wichtige Punkte zum STL-Sortieren:

• Inkludieren Sie die <algorithm>-Bibliothek für das Sortieren.
• std::sort() funktioniert mit verschiedenen Containern.
• Die Standard-Sortierreihenfolge ist aufsteigend.
• std::greater<type>() sortiert in absteigender Reihenfolge.
• Das Sortieren erfolgt direkt im Container und ändert den ursprünglichen Container.
• Es funktioniert effizient mit verschiedenen Containertypen.

Suchen von Elementen mit STL-Algorithmen

In diesem Schritt lernen Sie, wie Sie STL-Algorithmen verwenden, um Elemente in Containern zu finden und zu suchen. Die <algorithm>-Bibliothek bietet leistungsstarke Funktionen für die Suche und Lokalisierung von Elementen.

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

touch ~/project/find_demo.cpp

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

#include <iostream>
#include <vector>
#include <algorithm>

int main() {
    // Create a vector of integers
    std::vector<int> numbers = {5, 2, 8, 1, 9, 3, 8};

    // Find first occurrence of a specific element
    auto it = std::find(numbers.begin(), numbers.end(), 8);
    if (it!= numbers.end()) {
        std::cout << "First occurrence of 8 at index: "
                  << std::distance(numbers.begin(), it) << std::endl;
    }

    // Count occurrences of an element
    int count = std::count(numbers.begin(), numbers.end(), 8);
    std::cout << "Number of 8s in the vector: " << count << std::endl;

    // Find if any element is greater than 6
    bool has_large_element = std::any_of(numbers.begin(), numbers.end(),
        [](int n) { return n > 6; });
    std::cout << "Vector has element > 6: "
              << (has_large_element? "Yes" : "No") << std::endl;

    // Find the minimum and maximum elements
    auto min_it = std::min_element(numbers.begin(), numbers.end());
    auto max_it = std::max_element(numbers.begin(), numbers.end());

    std::cout << "Minimum element: " << *min_it << std::endl;
    std::cout << "Maximum element: " << *max_it << std::endl;

    return 0;
}

Kompilieren und führen Sie das Programm aus:

g++ find_demo.cpp -o find_demo
./find_demo

Beispielausgabe:

First occurrence of 8 at index: 2
Number of 8s in the vector: 2
Vector has element > 6: Yes
Minimum element: 1
Maximum element: 9

Wichtige Punkte zu STL-Suchalgorithmen:

• std::find() findet das erste Vorkommen eines Elements.
• std::count() zählt die Vorkommen eines Elements.
• std::any_of() prüft, ob irgendein Element eine Bedingung erfüllt.
• std::min_element() und std::max_element() finden Extreme-Werte.
• Lambda-Funktionen können für benutzerdefinierte Suchbedingungen verwendet werden.
• Die zurückgegebenen Iteratoren zeigen auf die gefundenen Elemente.

Durch Container iterieren

In diesem Schritt lernen Sie verschiedene Methoden kennen, um durch STL-Container zu iterieren, indem Sie verschiedene Iterationstechniken verwenden. Wir werden Bereichsbasierte for-Schleifen, Iteratoren und die traditionelle indexbasierte Iteration untersuchen.

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

touch ~/project/iteration_demo.cpp

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

#include <iostream>
#include <vector>
#include <list>
#include <map>

int main() {
    // Vector iteration
    std::vector<int> numbers = {10, 20, 30, 40, 50};

    // Method 1: Range-based for loop (most modern and readable)
    std::cout << "Vector iteration (range-based for):" << std::endl;
    for (int num : numbers) {
        std::cout << num << " ";
    }
    std::cout << std::endl;

    // Method 2: Iterator-based iteration
    std::cout << "Vector iteration (iterators):" << std::endl;
    for (auto it = numbers.begin(); it!= numbers.end(); ++it) {
        std::cout << *it << " ";
    }
    std::cout << std::endl;

    // Method 3: Index-based iteration
    std::cout << "Vector iteration (index-based):" << std::endl;
    for (size_t i = 0; i < numbers.size(); ++i) {
        std::cout << numbers[i] << " ";
    }
    std::cout << std::endl;

    // Map iteration
    std::map<std::string, int> ages = {
        {"Alice", 25},
        {"Bob", 30},
        {"Charlie", 35}
    };

    std::cout << "Map iteration:" << std::endl;
    for (const auto& pair : ages) {
        std::cout << pair.first << ": " << pair.second << std::endl;
    }

    return 0;
}

Kompilieren und führen Sie das Programm aus:

g++ iteration_demo.cpp -o iteration_demo
./iteration_demo

Beispielausgabe:

Vector iteration (range-based for):
10 20 30 40 50
Vector iteration (iterators):
10 20 30 40 50
Vector iteration (index-based):
10 20 30 40 50
Map iteration:
Alice: 25
Bob: 30
Charlie: 35

Wichtige Punkte zur Containeriteration:

• Bereichsbasierte for-Schleifen sind die modernste und am besten lesbare Methode.
• Iteratoren bieten eine feingranulare Kontrolle über die Containerdurchquerung.
• Die indexbasierte Iteration funktioniert gut mit Containern, die einen wahlfreien Zugriff unterstützen.
• Das Schlüsselwort auto hilft bei der Typinferenz.
• Verschiedene Container unterstützen verschiedene Iterationsmethoden.

Verwendung von STL Stack und Queue

In diesem Schritt lernen Sie zwei wichtige STL-Containeradapter kennen: Stack und Queue. Diese Container bieten spezialisierte Operationen für die Verwaltung von Daten nach dem Prinzip "Last In, First Out" (LIFO) und "First In, First Out" (FIFO).

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

touch ~/project/stack_queue_demo.cpp

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

#include <iostream>
#include <stack>
#include <queue>

int main() {
    // Stack demonstration
    std::stack<int> myStack;

    // Push elements onto the stack
    myStack.push(10);
    myStack.push(20);
    myStack.push(30);

    std::cout << "Stack operations:" << std::endl;
    std::cout << "Top element: " << myStack.top() << std::endl;

    // Remove top element
    myStack.pop();
    std::cout << "Top element after pop: " << myStack.top() << std::endl;
    std::cout << "Stack size: " << myStack.size() << std::endl;

    // Queue demonstration
    std::queue<std::string> myQueue;

    // Add elements to the queue
    myQueue.push("Alice");
    myQueue.push("Bob");
    myQueue.push("Charlie");

    std::cout << "\nQueue operations:" << std::endl;
    std::cout << "Front element: " << myQueue.front() << std::endl;
    std::cout << "Back element: " << myQueue.back() << std::endl;

    // Remove front element
    myQueue.pop();
    std::cout << "Front element after pop: " << myQueue.front() << std::endl;
    std::cout << "Queue size: " << myQueue.size() << std::endl;

    return 0;
}

Kompilieren und führen Sie das Programm aus:

g++ stack_queue_demo.cpp -o stack_queue_demo
./stack_queue_demo

Beispielausgabe:

Stack operations:
Top element: 30
Top element after pop: 20
Stack size: 2

Queue operations:
Front element: Alice
Back element: Charlie
Front element after pop: Bob
Queue size: 2

Wichtige Punkte zu Stack und Queue:

• Stack (LIFO - Last In, First Out)
  • push() fügt ein Element oben auf den Stack hinzu.
  • pop() entfernt das oberste Element.
  • top() gibt das oberste Element zurück.
• Queue (FIFO - First In, First Out)
  • push() fügt ein Element am Ende der Queue hinzu.
  • pop() entfernt das erste Element.
  • front() gibt das erste Element zurück.
  • back() gibt das letzte Element zurück.
• Beide haben die Methode size(), um die Anzahl der Elemente zu überprüfen.
• Inkludieren Sie die Header <stack> und <queue>.

Behandlung der Ausnahmesicherheit von Containern

In diesem Schritt lernen Sie, wie Sie Ausnahmen behandeln und sichere Operationen mit STL-Containern gewährleisten können. Die Behandlung von Ausnahmen hilft, Programmabstürze zu vermeiden und bietet eine robuste Fehlerverwaltung.

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

touch ~/project/exception_safety_demo.cpp

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

#include <iostream>
#include <vector>
#include <stdexcept>

void demonstrateVectorSafety() {
    std::vector<int> numbers;

    try {
        // Attempt to access an element from an empty vector
        std::cout << "Attempting to access element from empty vector:" << std::endl;
        numbers.at(0);  // This will throw an out_of_range exception
    }
    catch (const std::out_of_range& e) {
        std::cout << "Out of Range Error: " << e.what() << std::endl;
    }

    // Safe element addition
    try {
        numbers.push_back(10);
        numbers.push_back(20);
        std::cout << "Vector size: " << numbers.size() << std::endl;

        // Safe element access
        std::cout << "First element: " << numbers.at(0) << std::endl;
        std::cout << "Second element: " << numbers.at(1) << std::endl;
    }
    catch (const std::exception& e) {
        std::cout << "An error occurred: " << e.what() << std::endl;
    }
}

int main() {
    // Demonstrate vector exception safety
    demonstrateVectorSafety();

    return 0;
}

Kompilieren und führen Sie das Programm aus:

g++ exception_safety_demo.cpp -o exception_safety_demo
./exception_safety_demo

Beispielausgabe:

Attempting to access element from empty vector:
Out of Range Error: vector
Vector size: 2
First element: 10
Second element: 20

Wichtige Punkte zur Behandlung von Ausnahmen bei Containern:

• Verwenden Sie try-catch-Blöcke, um potenzielle Ausnahmen zu behandeln.
• std::out_of_range wird ausgelöst, wenn Sie auf ungültige Vektorelemente zugreifen.
• Die Methode at() führt eine Bereichsprüfung durch, im Gegensatz zum []-Operator.
• Fangen Sie zunächst spezifische Ausnahmen ab, dann allgemeinere.
• Behandeln Sie immer potenzielle Ausnahmen, um Programmabstürze zu vermeiden.
• Verwenden Sie Standard-Ausnahmeklassen aus <stdexcept>.

Zusammenfassung

In diesem Lab haben Sie verschiedene Komponenten der C++ Standard Template Library (STL) kennengelernt und erfahren, wie Sie sie effektiv einsetzen können. Sie haben zunächst den vector-Container untersucht, ein dynamisches Array, dessen Größe sich vergrößern und verkleinern lässt. Sie haben gelernt, wie Sie Elemente hinzufügen und entfernen, über Indizes darauf zugreifen und mithilfe einer bereichsbasierenden for-Schleife durch den vector iterieren können.

Als Nächstes haben Sie sich mit dem list-Container beschäftigt, einer Implementierung einer doppelt verketteten Liste. Sie haben herausgefunden, wie Sie gängige Operationen an verketteten Listen wie Einfügen, Löschen und Durchlaufen von Elementen ausführen können. Sie haben auch den map-Container kennengelernt, der es Ihnen ermöglicht, Schlüssel-Wert-Paare zu speichern, sowie den set-Container, der einzigartige Elemente speichert. Darüber hinaus haben Sie gelernt, wie Sie STL-Algorithmen wie sort und find verwenden können, um Elemente in diesen Containern zu manipulieren und zu suchen. Schließlich haben Sie die stack- und queue-Container untersucht und die Wichtigkeit der Ausnahme-Sicherheit (Exception Safety) beim Arbeiten mit STL-Komponenten besprochen.