Rust-ohjelmoinnin perusteet · Oppitunti

Geneeriset structit ja enumit

Rakentakaa joustavia tietotyyppejä.

Oppitunti 2/413 vaihetta

Geneeriset structit ja enumit on ilmainen Rust-ohjelmoinnin perusteet-oppitunti CoddyKitissä. Tämä on oppitunti 2/4. Voit lukea tästä oppimispolusta kokonaan mitkä tahansa 3 oppituntia ilmaiseksi — sen jälkeen CoddyKit PRO avaa kaikki oppitunnit sekä käytännön harjoittelun sisäänrakennetulla koodieditorilla ja ympäri vuorokauden toimivalla tekoälytuutorilla. Oppitunti kuuluu Rust-ohjelmoinnin perusteet-oppimispolkuun, ja edistymisesi synkronoituu verkon ja CoddyKit-sovelluksen välillä. Rust-ohjelmoinnin perusteet-kurssilla on yhteensä 4 oppituntia.

Geneeriset tietorakenteet

Funktioiden tavoin myös structit ja enumit voivat olla geneerisiä yhden tai useamman tyypin suhteen. Näin yksi määrittely voi sisältää minkä tahansa tyyppisiä arvoja.

Standardikirjasto on rakennettu tällä tavalla: Vec<T>, Option<T> ja Result<T, E> ovat kaikki geneerisiä.

Geneerinen struct

Ilmoittakaa tyyppiparametri structin nimen jälkeen ja käyttäkää sitä kentissä. Tässä Point sisältää kaksi saman tyypin T arvoa.

Yksi määrittely palvelee nyt kokonaisluku-, liukuluku- ja muita pisteitä.

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

Geneeristen structien luominen

Kun luotte ilmentymän, kääntäjä päättelee T-tyypin kenttien arvoista. Molempien kenttien on oltava samaa tyyppiä.

Tämä ohjelma muodostaa kokonaisluku- ja liukulukupisteen samasta structista.

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

Eriävät tyyppiparametrit

Kahden parametrin käyttäminen sallii kenttien eriävät tyypit. Pair<T, U> voi sisältää samanaikaisesti kokonaisluvun ja merkkijonon.

Käyttäkää yhtä parametria, kun kenttien on oltava samaa tyyppiä, ja useita, kun tyypit voivat vaihdella.

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

Geneeristen structien metodit

Lisätessänne metodeja toistakaa tyyppiparametri impl-lohkossa: impl<T> Point<T>. impl-sanan jälkeinen parametri ilmoittaa parametrin ja tyypin nimen jälkeinen parametri käyttää sitä.

Tässä getter palauttaa viitteen x-kenttään.

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

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

Rajoitetut metodit

Voitte kirjoittaa metodeja vain tietyille konkreettisille tyypeille tai rajoitteen täyttäville tyypeille. Tämä impl koskee vain tyyppiä Point<f64>.

Siksi dist_from_origin on olemassa liukulukupisteille mutta ei kokonaislukupisteille.

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

Geneerinen enum

Myös enumit voivat olla geneerisiä. Kukin variantti voi sisältää geneeristä dataa. Tämä vastaa standardin Option-tyyppiä, joka on joko Some(T) tai None.

Oman version määrittäminen auttaa näkemään, miten kirjaston tyyppi toimii.

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

Kaksi parametria enumissa

Result käyttää kahta parametria, jotta onnistumis- ja virhearvoilla voi olla eri tyypit. Tässä on yksinkertaistettu versio.

Enumien useat tyyppiparametrit mahdollistavat joustavan virheenkäsittelyn koko ekosysteemissä.

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

Geneeristen enumien käsittely

Voitte käyttää geneeristen enumien rakenteen purkua täsmälleen kuten konkreettisten enumien kanssa. Rajoitteen mukainen sisältöarvo sidotaan muuttujaan haarassa.

Tämä ohjelma purkaa mukautetun Maybe-arvon ja tulostaa sen sisältämän arvon tai oletusarvon.

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"),
    }
}

Arvon kääriminen

Yleinen malli on yhden T-tyyppisen kentän sisältävä wrapper-struct, jolla on apumetodeja. Tässä Wrapper tallentaa minkä tahansa arvon ja palauttaa sen.

Tämä on newtype-mallien ja älyosoitintyyppisten tyyppien perusta.

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

Ei ajonaikaista lisäkustannusta

Myös geneeriset structit ja enumit monomorfisoidaan. Point<i32> ja Point<f64> muuttuvat käännöksen jälkeen kahdeksi erilliseksi, täysin erikoistetuksi tyypiksi.

Geneeriselle tyypille ei ole piilotettua epäsuoraa käsittelyä tai tunnistetta.

Pikatarkistus

Testatkaa ymmärrystänne geneerisistä struct- ja enum-tyypeistä.

Vastaa interaktiivisessa oppitunnissa

Kertaus

Structit ja enumit ilmoittavat tyyppiparametrit nimensä jälkeen ja käyttävät niitä kentissä ja varianteissa, mikä mahdollistaa uudelleenkäytettävät säilöt, kuten Option- ja Result-tyypit.

Metodit toistavat parametrit muodossa impl<T>, ja konkreettisille tyypeille voi kirjoittaa erikoistettuja impl-lohkoja. Kaikki monomorfisoidaan ilman ajonaikaista lisäkustannusta.

Aloita maksutta

Opi Rust tekoälytuutorin avulla — ilmaiseksi

Kirjoita ja suorita oikeaa koodia selaimessa, saa välitöntä apua tekoälytuutorilta ympäri vuorokauden ja jatka siitä, mihin jäit, verkossa tai sovelluksessa.

Kurssit: 39
Oppitunnit: 144

Aloita opiskelu maksutta Näytä koko kurssi

Usein kysytyt kysymykset

Onko oppitunti ”Geneeriset structit ja enumit” ilmainen?

Kyllä — voit lukea täällä verkossa kokonaan ilmaiseksi mitkä tahansa Rust-ohjelmoinnin perusteet-oppimispolun 3 oppituntia, myös oppitunnin “Geneeriset structit ja enumit”. Sen jälkeen CoddyKit PRO avaa kaikki oppitunnit sekä interaktiiviset harjoitukset sisäänrakennetulla koodieditorilla ja ympäri vuorokauden toimivalla tekoälytuutorilla. Rust-ohjelmoinnin perusteet-kurssilla on yhteensä 4 oppituntia.

Mitä opin oppitunnilla ”Geneeriset structit ja enumit”?

Rakentakaa joustavia tietotyyppejä. Harjoittelet Rust-ohjelmoinnin perusteet-aihetta koodilla, jonka suoritat suoraan selaimessa. Ympäri vuorokauden käytettävissä oleva tekoälytuutori vastaa kysymyksiisi oppitunnin aikana.

Tarvitsenko kokemusta aloittaakseni Rust-ohjelmoinnin perusteet-opiskelun?

Aiempi kokemus ei ole tarpeen. CoddyKitin Rust-ohjelmoinnin perusteet-oppimispolku sopii vasta-alkajista edistyneisiin, joten voit aloittaa tästä tai alusta ja edetä omaan tahtiisi. Tämä on oppitunti 2/4.

Kuinka kauan ”Geneeriset structit ja enumit”-oppitunnin suorittaminen kestää?

Useimmat CoddyKitin oppitunnit kestävät noin 5–10 minuuttia. Jokainen oppitunti on lyhyt ja interaktiivinen, joten edistyt tasaisesti ja voit jatkaa siitä, mihin jäit – sekä verkossa että sovelluksessa.

Voinko kirjoittaa ja suorittaa koodia tällä Rust-ohjelmoinnin perusteet-oppitunnilla?

Kyllä. Jokainen Rust-ohjelmoinnin perusteet-oppitunti sisältää sisäänrakennetun koodieditorin, joten voit kirjoittaa ja suorittaa oikeaa koodia suoraan selaimessa ja saada välitöntä palautetta tekoälyltä – paikallista asennusta ei tarvita.

Kaikki tämän kurssin oppitunnit

← Takaisin: Rust-ohjelmoinnin perusteet