C++ Academy · Lektion

Grenzen und Subspans

Spans sicher aufteilen

Grenzen und Subspans 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.

Aufteilen mit subspan

s.subspan(offset, count) gibt einen Span über einen Teil des ursprünglichen Spans zurück – ohne Kopie, nur mit einem neuen Zeiger und einer neuen Länge.

#include <iostream>
#include <span>
int main() {
    int buf[] = {0, 1, 2, 3, 4};
    std::span<int> s(buf, 5);
    auto mid = s.subspan(1, 3);
    for (int x : mid) std::cout << x << " ";
    std::cout << "\n"; // 1 2 3
}

first und last

first(n) und last(n) liefern Spans über die ersten bzw. letzten n Elemente.

#include <iostream>
#include <span>
int main() {
    int buf[] = {10, 20, 30, 40};
    std::span<int> s(buf, 4);
    auto f = s.first(2);
    auto l = s.last(2);
    std::cout << f[0] << " " << l[1] << "\n"; // 10 40
}

Subspans teilen den Speicher

Wenn Sie einen Subspan ändern, ändern Sie die ursprünglichen Daten, da beide auf denselben Puffer zeigen.

#include <iostream>
#include <span>
int main() {
    int buf[] = {1, 1, 1, 1};
    std::span<int> s(buf, 4);
    auto tail = s.last(2);
    tail[0] = 99;
    std::cout << buf[2] << "\n"; // 99
}

size_bytes

size_bytes() gibt die gesamte Byte-Größe der Elemente des Spans zurück, was für Ein-/Ausgaben auf niedriger Ebene nützlich ist.

#include <iostream>
#include <span>
int main() {
    int buf[] = {1, 2, 3};
    std::span<int> s(buf, 3);
    std::cout << s.size_bytes() << "\n"; // 3 * sizeof(int)
}

Für die Grenzen sind Sie verantwortlich

operator[] eines Spans prüft die Grenzen nicht. Das Lesen von s[s.size()] ist undefiniertes Verhalten.

Vor dem Aufteilen prüfen

Der Aufruf von subspan mit einem Offset oder einer Anzahl, die größer als der Span ist, führt zu undefiniertem Verhalten. Prüfen Sie daher zuerst gegen size().

#include <iostream>
#include <span>
int main() {
    int buf[] = {1, 2, 3};
    std::span<int> s(buf, 3);
    size_t off = 1, cnt = 2;
    if (off + cnt <= s.size()) {
        auto sub = s.subspan(off, cnt);
        std::cout << sub.size() << "\n";
    }
}

Nach dem Aufteilen leer

Durch Aufteilen kann ein leerer Span entstehen, zum Beispiel mit first(0). Behandeln Sie ihn wie jeden leeren Bereich.

#include <iostream>
#include <span>
int main() {
    int buf[] = {1, 2};
    std::span<int> s(buf, 2);
    auto e = s.first(0);
    std::cout << e.empty() << "\n"; // 1
}

Aufteilen verkettet durchführen

Subspans können weiter aufgeteilt werden, da jeder lediglich eine weitere Ansicht auf den ursprünglichen Puffer ist.

#include <iostream>
#include <span>
int main() {
    int buf[] = {0, 1, 2, 3, 4, 5};
    std::span<int> s(buf, 6);
    auto inner = s.subspan(1, 4).first(2);
    std::cout << inner[0] << " " << inner[1] << "\n"; // 1 2
}

Verarbeitung in Blöcken

Eine häufige Verwendung von subspan besteht darin, einen großen Puffer für Streaming oder Batch-Verarbeitung in Fenstern fester Größe zu durchlaufen.

#include <iostream>
#include <span>
int main() {
    int buf[] = {1, 2, 3, 4, 5, 6};
    std::span<int> s(buf, 6);
    for (size_t i = 0; i < s.size(); i += 2) {
        auto chunk = s.subspan(i, 2);
        std::cout << "[" << chunk[0] << "," << chunk[1] << "] ";
    }
    std::cout << "\n";
}

Prüfungen für statischen Extent

Bei einem Span mit statischem Extent kann der Compiler einige Größen der Teilbereiche zur Compile-Zeit überprüfen und Fehler früher erkennen.

Die Lebensdauer gilt weiterhin

Jeder Subspan teilt die Lebensdauer des ursprünglichen Puffers. Wenn die Quelle zerstört oder neu allokiert wird, werden alle daraus abgeleiteten Spans ungültig.

Kurze Überprüfung

Überprüfen Sie Ihr Verständnis von Subspans und Grenzen.

Zusammenfassung

Sie haben Grenzen und Subspans kennengelernt:

subspan, first und last erstellen Slices ohne Allokation.
Subspans teilen den Speicher; Änderungen wirken sich auf die ursprünglichen Daten aus.
operator[] und das Aufteilen prüfen die Grenzen nicht. Prüfen Sie daher zuerst.
Alle Subspans teilen die Lebensdauer der Quelle.

Häufig gestellte Fragen

Ist die Lektion „Grenzen und Subspans“ kostenlos?

Ja — der vollständige Text von „Grenzen und Subspans“ 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 „Grenzen und Subspans“?

Spans sicher 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 „Grenzen und Subspans“?

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