Learn Rust Coding · Lekcja

Generyczne struktury i enumy

Zbuduje Pan/Pani elastyczne typy danych.

Generyczne struktury i enumy to bezpłatna lekcja Learn Rust Coding na CoddyKit. To lekcja 2 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 Learn Rust Coding, a Twój postęp synchronizuje się między webem a aplikacją CoddyKit. Kurs Learn Rust Coding zawiera 4 lekcji w sumie.

Generyczne struktury danych

Podobnie jak funkcje, struktury i wyliczenia mogą być generyczne względem jednego lub większej liczby typów. Dzięki temu jedna definicja może przechowywać wartości dowolnego typu.

W ten sposób zbudowana jest biblioteka standardowa: Vec<T>, Option<T> i Result<T, E> są typami generycznymi.

Generyczna struktura

Zadeklaruj parametr typu po nazwie struktury, a następnie użyj go dla pól. W tym przypadku Point przechowuje dwie wartości tego samego typu T.

Jedna definicja obsługuje teraz punkty z liczbami całkowitymi, punkty z liczbami zmiennoprzecinkowymi i wiele innych.

struct Point<T> {
    x: T,
    y: T,
}

Tworzenie struktur generycznych

Podczas tworzenia instancji kompilator wywnioskuje T na podstawie wartości pól. Oba pola muszą mieć ten sam typ.

Ten program tworzy punkt z liczbą całkowitą i punkt z liczbą zmiennoprzecinkową na podstawie tej samej struktury.

struct Point<T> {
    x: T,
    y: T,
}

fn main() {
    let a = Point { x: 1, y: 2 };
    let b = Point { x: 1.5, y: 4.0 };
    println!("{} {}", a.x, b.y);
}

Parametry typów mieszanych

Użycie dwóch parametrów pozwala polom mieć różne typy. Pair<T, U> może jednocześnie przechowywać liczbę całkowitą i łańcuch znaków.

Wybierz jeden parametr, gdy pola muszą mieć ten sam typ, oraz kilka, gdy ich typy mogą się różnić.

struct Pair<T, U> {
    first: T,
    second: U,
}

Metody struktur generycznych

Aby dodać metody, powtórz parametr typu w bloku impl: impl<T> Point<T>. Parametr po słowie impl go deklaruje, a parametr po nazwie typu go stosuje.

W tym przypadku metoda dostępowa zwraca referencję do pola x.

struct Point<T> {
    x: T,
    y: T,
}

impl<T> Point<T> {
    fn x(&self) -> &T {
        &self.x
    }
}

Metody z ograniczeniami

Możesz pisać metody tylko dla określonych typów konkretnych albo dla typów spełniających dane ograniczenie. Ten blok impl dotyczy wyłącznie Point<f64>.

Dlatego dist_from_origin istnieje dla punktów zmiennoprzecinkowych, ale nie dla punktów z liczbami całkowitymi.

struct Point<T> { x: T, y: T }

impl Point<f64> {
    fn dist_from_origin(&self) -> f64 {
        (self.x * self.x + self.y * self.y).sqrt()
    }
}

Generyczne wyliczenie

Wyliczenia również mogą być generyczne. Każdy wariant może przechowywać dane generyczne. Odzwierciedla to standardowy typ Option, który jest albo Some(T), albo None.

Zdefiniowanie własnego typu pomaga zrozumieć działanie typu bibliotecznego.

enum Maybe<T> {
    Just(T),
    Nothing,
}

Dwa parametry w wyliczeniu

Result używa dwóch parametrów, aby wartości oznaczające powodzenie i błąd mogły mieć różne typy. Oto jego uproszczona wersja.

Wiele parametrów typów w wyliczeniach umożliwia elastyczną obsługę błędów w całym ekosystemie.

enum Either<L, R> {
    Left(L),
    Right(R),
}

Dopasowywanie generycznych wyliczeń

Dopasowywanie wzorców generycznych wyliczeń działa dokładnie tak samo jak w przypadku wyliczeń konkretnych. Wartość przechowywana w wariancie staje się wiązaniem wewnątrz ramienia.

Ten program rozpakowuje własny typ Maybe i wyświetla zawartą wartość albo wartość zastępczą.

enum Maybe<T> { Just(T), Nothing }

fn main() {
    let m: Maybe<i32> = Maybe::Just(5);
    match m {
        Maybe::Just(n) => println!("got {}", n),
        Maybe::Nothing => println!("empty"),
    }
}

Opakowywanie wartości

Częstym schematem jest struktura opakowująca z jednym polem typu T oraz metodami pomocniczymi. W tym przypadku Wrapper przechowuje i zwraca dowolną wartość.

To podstawa wzorców newtype i typów przypominających inteligentne wskaźniki.

struct Wrapper<T> { inner: T }

impl<T> Wrapper<T> {
    fn new(v: T) -> Self {
        Wrapper { inner: v }
    }
}

fn main() {
    let w = Wrapper::new("hi");
    println!("{}", w.inner);
}

Brak narzutu w czasie wykonywania

Generyczne struktury i wyliczenia również podlegają monomorfizacji. Po kompilacji Point<i32> i Point<f64> stają się dwoma odrębnymi, w pełni wyspecjalizowanymi typami.

Nie ma tu ukrytego poziomu pośredniego ani znacznika określającego sam typ generyczny.

Szybkie sprawdzenie

Sprawdź swoją wiedzę na temat generycznych struktur i wyliczeń.

Podsumowanie

Struktury i wyliczenia deklarują parametry typów po swoich nazwach i używają ich w polach oraz wariantach, umożliwiając tworzenie wielokrotnego użytku kontenerów, takich jak Option i Result.

Metody powtarzają parametry w impl<T>, a wyspecjalizowane bloki impl można pisać dla konkretnych typów. Wszystko jest monomorfizowane, więc nie występuje dodatkowy narzut.

Często zadawane pytania

Czy lekcja „Generyczne struktury i enumy” jest bezpłatna?

Tak — pełny tekst „Generyczne struktury i enumy” 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 Learn Rust Coding, przejdź na CoddyKit PRO. Kurs Learn Rust Coding zawiera 4 lekcji w sumie.

Co nauczysz się w „Generyczne struktury i enumy”?

Zbuduje Pan/Pani elastyczne typy danych. Ćwiczysz Learn Rust Coding 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ąć Learn Rust Coding?

Nie wymagamy żadnego doświadczenia. Learn Rust Coding 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 2 z 4.

Ile czasu zajmuje lekcja „Generyczne struktury i enumy”?

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 Learn Rust Coding?

Tak. Każda lekcja Learn Rust Coding 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 Learn Rust Coding