C++ Academy · Lekcja

Zakresy i podspany

Bezpiecznie wycinaj fragmenty spanów

Zakresy i podspany to bezpłatna lekcja C++ Academy na CoddyKit. To lekcja 4 z 4. Możesz przeczytać całą lekcję poniżej za darmo — a potem ćwiczyć ją interaktywnie w przeglądarce z wbudowanym edytorem kodu i tutorem AI dostępnym 24/7. To część ścieżki edukacyjnej C++ Academy, a Twój postęp synchronizuje się między webem a aplikacją CoddyKit. Kurs C++ Academy zawiera 4 lekcji w sumie.

Wycinanie za pomocą subspan

s.subspan(offset, count) zwraca span obejmujący część oryginalnego zakresu; nie wykonuje kopiowania, a jedynie tworzy nowy wskaźnik i długość.

#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 i last

first(n) i last(n) zwracają spany obejmujące odpowiednio pierwsze lub ostatnie n elementów.

#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
}

Subspany współdzielą pamięć

Modyfikowanie subspanu zmienia oryginalne dane, ponieważ oba wskazują na ten sam bufor.

#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() zwraca całkowity rozmiar elementów spanu w bajtach, co jest przydatne w niskopoziomowych operacjach wejścia-wyjścia.

#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)
}

Za zakres odpowiada programista

operator[] dla spanu nie sprawdza zakresu. Odczyt s[s.size()] jest niezdefiniowanym zachowaniem.

Sprawdzanie przed wycinaniem

Wywołanie subspan z przesunięciem lub liczbą elementów większą niż rozmiar spanu jest niezdefiniowanym zachowaniem; najpierw należy sprawdzić wartości względem 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";
    }
}

Pusty wynik wycinania

Wycinanie może zwrócić pusty span, na przykład first(0); należy obsługiwać go tak jak każdy pusty zakres.

#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
}

Łączenie operacji wycinania

Z subspanów można wycinać kolejne podzakresy, ponieważ każdy z nich jest tylko następnym widokiem na oryginalny bufor.

#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
}

Przetwarzanie w porcjach

Typowym zastosowaniem subspan jest iterowanie po dużym buforze za pomocą okien o stałym rozmiarze, na potrzeby strumieniowania lub przetwarzania partiami.

#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";
}

Sprawdzanie rozmiaru statycznego

W przypadku spanu ze statycznym rozmiarem kompilator może sprawdzić niektóre rozmiary wycinanych zakresów w czasie kompilacji, dzięki czemu błędy są wykrywane wcześniej.

Czas życia nadal ma znaczenie

Każdy subspan dzieli czas życia z oryginalnym buforem. Jeśli źródło zostanie zniszczone lub poddane realokacji, wszystkie utworzone spany staną się nieprawidłowe.

Szybkie sprawdzenie

Proszę sprawdzić zrozumienie subspanów i zakresów.

Podsumowanie

Poznali Państwo zakresy i subspany:

subspan, first i last tworzą wycinki bez alokacji.
Subspany współdzielą pamięć, więc modyfikacje wpływają na oryginał.
operator[] ani wycinanie nie sprawdzają zakresu; najpierw należy wykonać odpowiednią weryfikację.
Wszystkie subspany dzielą czas życia ze źródłem.

Często zadawane pytania

Czy lekcja „Zakresy i podspany” jest bezpłatna?

Tak — pełny tekst „Zakresy i podspany” jest dostępny za darmo tutaj w sieci. Aby ćwiczyć ją interaktywnie (wbudowany edytor kodu i tutor AI dostępny 24/7) i odblokować resztę kursu C++ Academy, przejdź na CoddyKit PRO. Kurs C++ Academy zawiera 4 lekcji w sumie.

Co nauczysz się w „Zakresy i podspany”?

Bezpiecznie wycinaj fragmenty spanów Ćwiczysz C++ Academy z praktycznym kodem, który uruchamiasz bezpośrednio w przeglądarce, a tutor AI dostępny 24/7 odpowiada na Twoje pytania podczas pracy nad lekcją.

Czy potrzebuję doświadczenia, aby zacząć C++ Academy?

Nie wymagamy żadnego doświadczenia. C++ Academy w CoddyKit jest strukturyzowany dla początkujących i zaawansowanych użytkowników, więc możesz zacząć tutaj lub od początku i uczyć się w swoim tempie. To lekcja 4 z 4.

Ile czasu zajmuje lekcja „Zakresy i podspany”?

Większość lekcji CoddyKit trwa około 5–10 minut. Każda lekcja to mały, interaktywny krok, dzięki czemu robisz systematyczne postępy i zawsze wracasz dokładnie do tego samego miejsca — na webie i w aplikacji.

Czy mogę pisać i uruchamiać kod w tej lekcji C++ Academy?

Tak. Każda lekcja C++ Academy zawiera wbudowany edytor kodu, więc piszesz i uruchamiasz prawdziwy kod bezpośrednio w przeglądarce i od razu otrzymujesz sprzężenie zwrotne od AI — bez konfiguracji na komputerze.

Wszystkie lekcje w tym kursie

← Powrót do C++ Academy