C++ Academy · Lektion

String-Algorithmen

Effizient suchen und aufteilen

String-Algorithmen ist eine kostenlose C++ Academy-Lektion auf CoddyKit. Dies ist Lektion 4 von 4. Du kannst die komplette Lektion unten kostenlos lesen – dann übst du sie direkt im Browser mit einem integrierten Code-Editor und einem KI-Tutor rund um die Uhr. Sie ist Teil des C++ Academy-Lernpfads, und dein Fortschritt wird über Web und CoddyKit-App synchronisiert. Der C++ Academy-Kurs umfasst insgesamt 4 Lektionen.

Mit find suchen

find gibt den Index eines Teilstrings oder npos zurück, wenn dieser nicht vorhanden ist, und arbeitet direkt auf einer View, ohne zu kopieren.

#include <iostream>
#include <string_view>
int main() {
    std::string_view sv = "key=value";
    auto pos = sv.find('=');
    std::cout << pos << "\n"; // 3
}

npos prüfen

Vergleichen Sie ein Suchergebnis immer mit std::string_view::npos, bevor Sie es als Index verwenden.

#include <iostream>
#include <string_view>
int main() {
    std::string_view sv = "abc";
    if (sv.find('z') == std::string_view::npos)
        std::cout << "not found\n";
}

Präfix- und Suffixprüfungen

starts_with und ends_with (C++20) machen die Absicht deutlich und vermeiden manuelle Vergleiche von Teilstrings.

#include <iostream>
#include <string_view>
int main() {
    std::string_view sv = "report.pdf";
    std::cout << sv.starts_with("report") << "\n";
    std::cout << sv.ends_with(".pdf") << "\n";
}

Ein Feld extrahieren

Kombinieren Sie find mit substr, um ein Schlüssel-Wert-Paar ohne Allokation neuer Strings aufzuteilen.

#include <iostream>
#include <string_view>
int main() {
    std::string_view sv = "name=Ada";
    auto eq = sv.find('=');
    std::cout << sv.substr(0, eq) << " : " << sv.substr(eq + 1) << "\n";
}

Am Trennzeichen aufteilen

Sie können die Tokens durchlaufen, indem Sie wiederholt das Trennzeichen suchen und Teil-Views bilden. Jedes Token ist lediglich eine View.

#include <iostream>
#include <string_view>
int main() {
    std::string_view sv = "a,b,c";
    size_t start = 0, pos;
    while ((pos = sv.find(',', start)) != std::string_view::npos) {
        std::cout << sv.substr(start, pos - start) << "\n";
        start = pos + 1;
    }
    std::cout << sv.substr(start) << "\n";
}

Vom Ende aus suchen

rfind sucht rückwärts. Das ist praktisch, um eine Dateierweiterung oder das letzte Trennzeichen zu ermitteln.

#include <iostream>
#include <string_view>
int main() {
    std::string_view path = "/usr/local/bin";
    auto slash = path.rfind('/');
    std::cout << path.substr(slash + 1) << "\n"; // bin
}

Leerraum entfernen

Verwenden Sie find_first_not_of und find_last_not_of zusammen mit remove_prefix/remove_suffix, um Leerraum ohne Kopieren zu entfernen.

#include <iostream>
#include <string_view>
int main() {
    std::string_view sv = "  hi  ";
    sv.remove_prefix(sv.find_first_not_of(" "));
    sv.remove_suffix(sv.size() - 1 - sv.find_last_not_of(" "));
    std::cout << "[" << sv << "]\n"; // [hi]
}

Views vergleichen

Views unterstützen == und compare für lexikografische Vergleiche. Verglichen werden Zeichen, nicht Zeiger.

#include <iostream>
#include <string_view>
int main() {
    std::string_view a = "apple", b = "apple";
    std::cout << (a == b) << "\n"; // 1
}

Vorkommen zählen

Eine Schleife mit find, die nach jedem Treffer hinter diesem weitersucht, zählt, wie oft ein Zeichen oder Teilstring vorkommt.

#include <iostream>
#include <string_view>
int main() {
    std::string_view sv = "mississippi";
    int count = 0;
    for (size_t p = sv.find('s'); p != std::string_view::npos; p = sv.find('s', p + 1)) ++count;
    std::cout << count << "\n"; // 4
}

Algorithmen bleiben speicherallokationsfrei

All diese Operationen arbeiten auf demselben zugrunde liegenden Puffer. Tokens und bereinigte Ergebnisse sind Teil-Views; erst beim Erstellen eines std::string wird Heap-Speicher allokiert.

Achten Sie auf die Lebensdauern

Die von diesen Algorithmen erzeugten Teil-Views teilen die Lebensdauer des ursprünglichen Puffers. Lassen Sie sie nicht länger als den Quell-String existieren.

Kurzer Test

Überprüfen Sie Ihr Verständnis der string_view-Algorithmen.

Zusammenfassung

Sie haben String-Algorithmen auf Views kennengelernt:

find/rfind geben Positionen oder npos zurück.
starts_with/ends_with prüfen Präfixe und Suffixe.
Aufteilen, Bereinigen und Tokenisieren erzeugen Teil-Views ohne Allokation.
Teil-Views teilen die Lebensdauer der Quelle – achten Sie auf Dangling-Views.

Häufig gestellte Fragen

Ist die Lektion „String-Algorithmen“ kostenlos?

Ja — der vollständige Text von „String-Algorithmen“ ist hier im Web kostenlos zu lesen. Um sie interaktiv zu üben (integrierter Code-Editor und 24/7 KI-Tutor) und den Rest des C++ Academy-Kurses freizuschalten, upgrade auf CoddyKit PRO. Der C++ Academy-Kurs umfasst insgesamt 4 Lektionen.

Was lerne ich in „String-Algorithmen“?

Effizient suchen und aufteilen Du übst C++ Academy mit praktischem Code, den du direkt im Browser ausführst, und ein 24/7 KI-Tutor beantwortet deine Fragen während du die Lektion bearbeitest.

Brauche ich Erfahrung, um C++ Academy zu starten?

Keine Vorkenntnisse erforderlich. C++ Academy auf CoddyKit ist für Anfänger bis fortgeschrittene Lernende strukturiert, sodass du hier starten oder von Anfang an beginnen und in deinem eigenen Tempo voranschreiten kannst. Dies ist Lektion 4 von 4.

Wie lange dauert die Lektion „String-Algorithmen“?

Die meisten CoddyKit-Lektionen dauern etwa 5–10 Minuten. Jede ist kompakt und interaktiv, sodass du stetig Fortschritte machst und genau dort weitermachst, wo du aufgehört hast – im Web und in der App.

Kann ich in dieser C++ Academy-Lektion Code schreiben und ausführen?

Ja. Jede C++ Academy-Lektion enthält einen integrierten Code-Editor, sodass du echten Code direkt in deinem Browser schreibst und ausführst und sofort KI-Feedback erhältst — ohne lokale Einrichtung erforderlich.

Alle Lektionen in diesem Kurs

← Zurück zu C++ Academy