Grenser og subspans
Del opp spans på en trygg måte
Grenser og subspans er en gratis leksjon i C++ Academy på CoddyKit. Dette er leksjon 4 av 4. Du kan lese valgfritt 3 leksjoner fra denne læringsstien gratis i sin helhet – deretter låser CoddyKit PRO opp alle leksjoner, samt praktisk øving med en innebygd kodeeditor og en AI-veileder som er tilgjengelig døgnet rundt. Den er en del av læringsløpet i C++ Academy, og fremdriften din synkroniseres mellom nettet og CoddyKit-appen. Kurset i C++ Academy inneholder totalt 4 leksjoner.
Oppdeling med subspan
s.subspan(offset, count) returnerer et span over en del av originalen, uten kopiering – bare en ny peker og lengde.
#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 og last
first(n) og last(n) gir span-objekter over henholdsvis de første og siste n elementene.
#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
}Delspan deler minne
Hvis De endrer et delspan, endres de opprinnelige dataene, fordi begge peker på den samme bufferen.
#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() returnerer den totale størrelsen i byte for elementene i span-objektet, noe som er nyttig ved I/O på lavt nivå.
#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)
}De har selv ansvar for grensene
operator[] på et span kontrollerer ikke grensene. Å lese s[s.size()] gir udefinert oppførsel.
Kontroller før oppdeling
Å kalle subspan med en forskyvning eller et antall som er større enn span-objektet, gir udefinert oppførsel. Valider derfor mot size() først.
#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";
}
}Tomt etter oppdeling
Oppdeling kan gi et tomt span, for eksempel first(0). Håndter det som alle andre tomme områder.
#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
}Kjede sammen oppdelinger
Delspan kan deles opp videre, siden hvert av dem bare er en ny visning inn i den opprinnelige bufferen.
#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
}Behandling i blokker
En vanlig bruk av subspan er å gå gjennom en stor buffer i vinduer med fast størrelse for strømming eller satsvis behandling.
#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";
}Kontroller av statisk utstrekning
Med et span med statisk utstrekning kan kompilatoren kontrollere enkelte oppdelingsstørrelser ved kompilering og dermed oppdage feil tidligere.
Levetiden gjelder fortsatt
Alle delspan deler levetiden til den opprinnelige bufferen. Hvis kilden destrueres eller allokeres på nytt, blir alle avledede span-objekter ugyldige.
Hurtigsjekk
Kontroller forståelsen Deres av delspan og grenser.
Oppsummering
De har lært om grenser og delspan:
subspan,firstoglastoppretter oppdelinger uten allokering.- Delspan deler minne, så endringer påvirker originalen.
operator[]og oppdeling utfører ikke grensekontroll. Valider først.- Alle delspan deler kildens levetid.
Lær deg C++ med en AI-veileder – gratis
Skriv og kjør ekte kode i nettleseren, få umiddelbar hjelp fra en AI-veileder som er tilgjengelig døgnet rundt, og fortsett der du slapp – på nettet eller i appen.
- Kurs
- 51
- Leksjoner
- 203
Ofte stilte spørsmål
Er leksjonen «Grenser og subspans» gratis?
Ja – du kan lese valgfritt 3 av leksjonene i læringsstien C++ Academy, inkludert «Grenser og subspans», gratis i sin helhet her på nettet. Deretter låser CoddyKit PRO opp alle leksjoner, samt interaktiv øving med en innebygd kodeeditor og en AI-veileder som er tilgjengelig døgnet rundt. Kurset i C++ Academy inneholder totalt 4 leksjoner.
Hva lærer jeg i «Grenser og subspans»?
Del opp spans på en trygg måte Du øver på C++ Academy med praktisk kode som du kjører direkte i nettleseren, mens en AI-veileder som er tilgjengelig døgnet rundt, svarer på spørsmålene dine mens du jobber deg gjennom leksjonen.
Trenger jeg erfaring for å begynne med C++ Academy?
Ingen tidligere erfaring er nødvendig. C++ Academy på CoddyKit er lagt opp for både nybegynnere og viderekomne, så De kan begynne her eller helt fra start og lære i Deres eget tempo. Dette er leksjon 4 av 4.
Hvor lang tid tar leksjonen «Grenser og subspans»?
De fleste CoddyKit-leksjoner tar omtrent 5–10 minutter. Hver leksjon er kort og interaktiv, slik at De gjør jevne fremskritt og kan fortsette akkurat der De slapp – både på nettet og i appen.
Kan jeg skrive og kjøre kode i denne C++ Academy-leksjonen?
Ja. Alle C++ Academy-leksjoner har en innebygd kodeeditor, slik at De kan skrive og kjøre ekte kode direkte i nettleseren og få umiddelbar tilbakemelding fra AI – uten lokal konfigurering.
Alle leksjonene i dette kurset
- std::array med fast størrelse
- Grunnleggende om std::span
- Sende spans til funksjoner
- Grenser og subspans