STL-Übersicht & Philosophie

Teil des Abschnitts Objektorientierte Programmierung der C++-Journey von Coddy. Lektion 70 von 104.

Die Standard Template Library (STL) ist eine Sammlung von klassen- und funktionsbasierten Vorlagen, die gängige Datenstrukturen und Algorithmen bereitstellt. Die STL basiert auf den Vorlagenkonzepten, die du kennengelernt hast, und verkörpert eine leistungsstarke Designphilosophie: die Datenspeicherung von der Datenverarbeitung zu trennen.

Die STL ist um drei zentrale Komponenten organisiert, die zusammenarbeiten:

Komponente	Zweck	Beispiele
Container	Sammlungen von Objekten speichern	`vector`, `map`, `set`
Iteratoren	Zugriff auf Elemente von Containern bereitstellen	Eingabe, Ausgabe, wahlfreier Zugriff
Algorithmen	Operationen auf Daten ausführen	`sort`, `find`, `transform`

Die zentrale Erkenntnis ist, dass Algorithmen Container nicht direkt kennen – sie arbeiten über Iteratoren. Das bedeutet, dass ein einzelner sort-Algorithmus mit Vektoren, Arrays und jedem Container funktioniert, der den passenden Iteratortyp bereitstellt:

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

int main() {
    std::vector<int> nums = {5, 2, 8, 1, 9};
    
    std::sort(nums.begin(), nums.end());
    
    for (int n : nums) {
        std::cout << n << " ";
    }
    // Ausgabe: 1 2 5 8 9
}

Diese Trennung bedeutet, dass du beliebig kombinieren kannst – verwende jeden Algorithmus mit jedem kompatiblen Container, ohne neuen Code schreiben zu müssen. Die STL stellt gründlich erprobte, optimierte Implementierungen bereit, sodass du dich auf das Lösen von Problemen konzentrieren kannst, anstatt gängige Datenstrukturen neu zu erfinden.

Aufgabe

Einfach

Erstellen wir ein einfaches Datenverarbeitungssystem, das die Designphilosophie der STL veranschaulicht: die Trennung von Containern, Iteratoren und Algorithmen. Du erstellst ein Dienstprogrammmodul, das mit STL-Komponenten arbeitet, sowie ein Hauptprogramm, das zeigt, wie diese Teile zusammenpassen.

Du erstellst zwei Dateien:

DataProcessor.h: Definiere Dienstprogrammfunktionen, die über Iteratoren mit STL-Containern arbeiten und dabei die Designphilosophie der STL veranschaulichen.
Erstelle eine Funktion namens printVector, die ein std::vector<int>& entgegennimmt und alle Elemente durch Leerzeichen getrennt ausgibt, gefolgt von einem Zeilenumbruch. Verwende Iteratoren (begin() und end()), um den Container zu durchlaufen.

Erstelle eine Funktion namens sortAndPrint, die ein std::vector<int>& entgegennimmt, ihn mit std::sort sortiert und anschließend die sortierten Elemente durch Leerzeichen getrennt ausgibt, gefolgt von einem Zeilenumbruch.

Erstelle eine Funktion namens findElement, die ein std::vector<int>& und einen zu suchenden int-Wert entgegennimmt. Verwende std::find, um das Element zu finden. Wenn es gefunden wird, gib Found: <value> aus. Wenn es nicht gefunden wird, gib Not found: <value> aus.

Erstelle eine Funktion namens getSum, die ein std::vector<int>& entgegennimmt und die Summe aller Elemente zurückgibt. Du kannst dafür eine einfache Schleife mit Iteratoren verwenden.
main.cpp: Lies Eingaben ein und veranschauliche, wie STL-Komponenten zusammenarbeiten.
Lies fünf Eingaben ein (jede in einer eigenen Zeile):
1. Erste ganze Zahl
2. Zweite ganze Zahl
3. Dritte ganze Zahl
4. Vierte ganze Zahl
5. Ein zu suchender Wert
Erstelle einen std::vector<int> und füge die ersten vier ganzen Zahlen hinzu. Veranschauliche anschließend die STL-Philosophie, indem du:
1. Original: ausgibst und danach printVector aufrufst
2. Sorted: ausgibst und danach sortAndPrint aufrufst
3. findElement mit dem Suchwert aufrufst
4. Sum: <result> mithilfe von getSum ausgibst

Bei den Eingaben 5, 2, 8, 1 und 8 erhältst du beispielsweise:

Original: 5 2 8 1 
Sorted: 1 2 5 8 
Found: 8
Sum: 16

Bei den Eingaben 10, 30, 20, 40 und 15 erhältst du:

Original: 10 30 20 40 
Sorted: 10 20 30 40 
Not found: 15
Sum: 100

Beachte, wie deine Funktionen über Iteratoren mit dem Vektor arbeiten und wie std::sort und std::find auf jedem Container funktionieren, der den richtigen Iteratortyp bereitstellt. Das ist die Stärke des STL-Designs: Algorithmen sind von Containern entkoppelt und nur über Iteratoren miteinander verbunden.

Probier es selbst

#include <iostream>
#include <vector>
#include "DataProcessor.h"

using namespace std;

int main() {
    // Lese fünf Ganzzahlen von der Eingabe
    int num1, num2, num3, num4, searchValue;
    cin >> num1;
    cin >> num2;
    cin >> num3;
    cin >> num4;
    cin >> searchValue;
    
    // TODO: Erstelle einen Vektor und füge die ersten vier Ganzzahlen hinzu
    
    // TODO: Gib "Original: " aus und rufe printVector auf
    
    // TODO: Gib "Sorted: " aus und rufe sortAndPrint auf
    
    // TODO: Rufe findElement mit dem Suchwert auf
    
    // TODO: Gib "Sum: " gefolgt vom Ergebnis von getSum aus
    
    return 0;
}