C++ Academy · Lektion

Spans an Funktionen übergeben

Flexible APIs schreiben

Spans an Funktionen übergeben ist eine kostenlose C++ Academy-Lektion auf CoddyKit. Dies ist Lektion 3 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.

Eine Funktion, viele Container

Eine Funktion, die std::span entgegennimmt, akzeptiert gleichermaßen Arrays, Vektoren und rohe Puffer – ganz ohne Templates oder Überladungen.

#include <iostream>
#include <span>
#include <vector>
#include <array>
int sum(std::span<const int> s) {
    int t = 0; for (int x : s) t += x; return t;
}
int main() {
    std::vector<int> v = {1, 2, 3};
    std::array<int, 2> a = {4, 5};
    std::cout << sum(v) << " " << sum(a) << "\n";
}

Kein Größenparameter erforderlich

Alte C-APIs übergeben einen Zeiger und eine separate Größe. Ein Span bündelt beides und verhindert Fehler durch nicht übereinstimmende Längen.

#include <iostream>
#include <span>
void printAll(std::span<const int> s) {
    for (int x : s) std::cout << x << " ";
    std::cout << "\n";
}
int main() {
    int buf[] = {7, 8, 9};
    printAll(buf); // size inferred
}

const span für schreibgeschützten Zugriff

Verwenden Sie std::span<const T>, um zuzusichern, dass die Funktion die Daten des Aufrufers nicht verändert.

#include <iostream>
#include <span>
int maxOf(std::span<const int> s) {
    int m = s[0];
    for (int x : s) if (x > m) m = x;
    return m;
}
int main() {
    int data[] = {3, 9, 4};
    std::cout << maxOf(data) << "\n"; // 9
}

Veränderbarer span zum Bearbeiten an Ort und Stelle

Ein nicht-const Span ermöglicht es einer Funktion, die Elemente des Aufrufers direkt zu verändern.

#include <iostream>
#include <span>
#include <vector>
void doubleAll(std::span<int> s) {
    for (int& x : s) x *= 2;
}
int main() {
    std::vector<int> v = {1, 2, 3};
    doubleAll(v);
    std::cout << v[2] << "\n"; // 6
}

Vermeidet Template-Aufblähung

Ohne Span würden Sie möglicherweise über den Containertyp parametrisieren, wodurch viele Instanziierungen erzeugt werden. Ein Span liefert eine konkrete Signatur, die einfach funktioniert.

Vermeidet Kopien

Beim Übergeben eines Spans werden die Elemente niemals kopiert; nur ein Zeiger und eine Länge gelangen in die Funktion.

#include <iostream>
#include <span>
#include <vector>
size_t count(std::span<const int> s) { return s.size(); }
int main() {
    std::vector<int> big(1000, 0);
    std::cout << count(big) << "\n"; // no copy of 1000 ints
}

Leere Spans sind unproblematisch

Eine Funktion sollte einen leeren Span problemlos verarbeiten können; size() ist null und die bereichsbasierte Schleife wird einfach nullmal ausgeführt.

#include <iostream>
#include <span>
int sum(std::span<const int> s) { int t = 0; for (int x : s) t += x; return t; }
int main() {
    std::span<const int> empty;
    std::cout << sum(empty) << "\n"; // 0
}

Per Wert übergeben

Spans sind sehr klein. Übergeben Sie sie daher per Wert, nicht per Referenz. Das Kopieren eines Zeigers und einer Länge ist praktisch kostenlos.

Die const-Absicht dokumentieren

Die Wahl zwischen span<const T> und span<T> zeigt Aufrufern auf einen Blick, ob ihre Daten verändert werden dürfen.

Der Aufrufer behält den Besitz

Der Aufrufer besitzt den Container weiterhin; der Span leiht ihn sich nur für die Dauer des Aufrufs. Die Funktion darf den Span nicht über den Aufruf hinaus speichern.

Ein moderner API-Stil

Die Entgegennahme eines Spans ist die idiomatische moderne Art, Funktionen für zusammenhängende Daten zu schreiben: flexibel, sicher und ohne Kopien.

Kurze Überprüfung

Überprüfen Sie Ihr Verständnis der Übergabe von Spans.

Zusammenfassung

Sie haben gelernt, Spans an Funktionen zu übergeben:

Eine Signatur akzeptiert Arrays, Vektoren und Puffer.
span<const T> für den schreibgeschützten Zugriff; span<T> zum Bearbeiten an Ort und Stelle.
Per Wert übergeben, ohne etwas zu kopieren.
Der Aufrufer behält den Besitz; speichern Sie den Span nicht über den Aufruf hinaus.

Häufig gestellte Fragen

Ist die Lektion „Spans an Funktionen übergeben“ kostenlos?

Ja — der vollständige Text von „Spans an Funktionen übergeben“ 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 „Spans an Funktionen übergeben“?

Flexible APIs schreiben 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 3 von 4.

Wie lange dauert die Lektion „Spans an Funktionen übergeben“?

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