Rust-ohjelmoinnin perusteet · Oppitunti

Sisäinen muokattavuus: RefCell ja Cell

Tutustutte `RefCell`- ja `Cell`-tyyppeihin sisäisen muokattavuuden toteuttamiseksi eli tietojen turvalliseen muuttamiseen muuttumattoman viitteen kautta.

Oppitunti 2/311 vaihetta

Sisäinen muokattavuus: RefCell ja Cell on ilmainen Rust-ohjelmoinnin perusteet-oppitunti CoddyKitissä. Tämä on oppitunti 2/3. 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ä 3 oppituntia.

Mitä on sisäinen muunneltavuus?

Rustissa lainaus- eli borrowing-säännöt estävät yleensä muuttamattoman viitteen olemassaolon aikana muuttuvan viitteen saamisen samoihin tietoihin. Tämä varmistaa tietojen turvallisuuden.

Sisäinen muunneltavuus on suunnittelumalli, jonka avulla tietoja voidaan muuttaa, vaikka käytettävissä olisi vain muuttumaton viite niihin. Se on eräänlainen hallittu poikkeus Rustin tavallisiin sääntöihin, ja sitä käytetään tietyissä tilanteissa.

`Cell<T>`: Copy-tyypeille

Cell<T>-tyyppi tarjoaa sisäisen muunneltavuuden tyypeille, jotka toteuttavat Copy-traitin, kuten kokonaisluvuille, totuusarvoille ja merkeille. Se toimii korvaamalla sisällä olevan arvon.

get(): Palauttaa Cell-säilössä olevan arvon kopion.
set(value): Korvaa Cell-säilössä olevan arvon uudella arvolla.

Se on yksinkertainen ja tehokas ratkaisu pienelle, kopioitavalle datalle.

Arvojen päivittäminen `Cell`-tyypin avulla

Tässä on yksinkertainen esimerkki Cell-tyypistä. Huomaa, miten voimme muuttaa Cell-säilön sisällä olevaa arvoa, vaikka itse Cell on määritetty muuttumattomaksi.

use std::cell::Cell;

fn main() {
  let my_num = Cell::new(10);
  println!("Initial value: {}", my_num.get());

  my_num.set(20);
  println!("Updated value: {}", my_num.get());

  let x = &my_num;
  x.set(30); // Still works via immutable reference!
  println!("Via immutable ref: {}", my_num.get());
}

`RefCell<T>`: ei-Copy-tyypeille

Kun tarvitsette sisäistä muunneltavuutta tyypeille, jotka eivät toteuta Copy-traitia (kuten String, Vec tai omat struct-tyypit), käytätte tyyppiä RefCell<T>.

RefCell mahdollistaa muunneltavien viitteiden hakemisen sisällä olevaan dataan, mutta se valvoo Rustin lainasääntöjä suorituksen aikana, ei käännösaikana.

`RefCell`-tyypin lainaus suorituksen aikana

RefCell tarjoaa metodeja, jotka palauttavat älykkäitä osoittimia:

borrow(): Palauttaa Ref-tyypin (muuttumattoman älykkään osoittimen). Samanaikaisesti voi olla useita muuttumattomia lainoja.
borrow_mut(): Palauttaa RefMut-tyypin (muunneltavan älykkään osoittimen). Kerrallaan voi olla vain yksi muunneltava laina.

Jos rikotte näitä sääntöjä suorituksen aikana, ohjelman suoritus päättyy panic!-virheeseen.

`RefCell`-tyypin käyttäminen (muuttumaton lainaus)

Tässä käytämme metodia borrow() saadaksemme muuttumattoman viitteen RefCell-tyypin sisällä olevaan String-arvoon. Voimme tulostaa sen sisällön.

use std::cell::RefCell;

fn main() {
  let my_string_cell = RefCell::new(String::from("Hello"));

  let s1 = my_string_cell.borrow();
  println!("Value: {}", *s1); // Dereference Ref to get String

  let s2 = my_string_cell.borrow(); // Multiple immutable borrows are fine
  println!("Another value: {}", *s2);
}

`RefCell`-tyypin käyttäminen (muunneltava lainaus)

Haetaan nyt muunneltava viite metodilla borrow_mut(). Näin voimme muokata String-arvoa. Huomaa, että kun s_mut on näkyvyysalueella, muita lainoja (muunneltavia tai muuttumattomia) ei sallita.

use std::cell::RefCell;

fn main() {
  let my_string_cell = RefCell::new(String::from("World"));

  { // Scope for the mutable borrow
    let mut s_mut = my_string_cell.borrow_mut();
    s_mut.push_str(", Rust!");
  }
  // s_mut is out of scope here, so we can borrow again

  let s_final = my_string_cell.borrow();
  println!("Final value: {}", *s_final);
}

`RefCell`-tyypin aiheuttama suoritusajan paniikki

Jos yritätte ottaa muunneltavan lainan, kun toinen muunneltava laina (tai mikä tahansa muuttumaton laina) on aktiivinen, RefCell aiheuttaa ohjelmassa suorituksen aikana panic!-virheen. Tämä estää datan vioittumisen.

Suorittakaa tämä koodi nähdäksenne, miten se toimii! Ohjelma kaatuu virheeseen "borrow already in use".

use std::cell::RefCell;

fn main() {
  let my_value = RefCell::new(vec![1, 2, 3]);

  let _first_mut_borrow = my_value.borrow_mut();
  println!("First mutable borrow is active.");

  // This line will cause a runtime panic!
  // Try commenting it out to see the program run successfully.
  let _second_mut_borrow = my_value.borrow_mut();

  println!("This line will not be reached.");
}

Yhteenveto: `Cell` vai `RefCell`

Valinta Cell- ja RefCell-tyypin välillä riippuu datatyypistänne ja siitä, miten tarvitsette käsitellä sitä:

Cell<T>: Käyttäkää tyypeille, jotka toteuttavat Copy-traitin. Se korvaa koko arvon ja on yleensä yksinkertaisempi sekä suorituskykyisempi.
RefCell<T>: Käyttäkää tyypeille, jotka eivät toteuta Copy-traitia. Se tarjoaa viitteet sisällä olevaan dataan ja valvoo lainasääntöjä suorituksen aikana, mikä mahdollistaa monimutkaisemmat muunnokset.

Pikatarkistus: `Cell` vai `RefCell`?

Teillä on struct, johon täytyy tallentaa muunneltava laskuri (u32) ja muunneltava nimilista (Vec<String>). Molempia täytyy päivittää muuttumattoman viitteen kautta struct-tyyppiin. Mitä sisäisen muunneltavuuden tyyppejä käyttäisitte kummallekin kentälle?

Vastaa interaktiivisessa oppitunnissa

Kertaus: sisäinen muunneltavuus

Olette tutustuneet Rustin sisäisen muunneltavuuden malliin, joka mahdollistaa datan hallitun ja turvallisen muokkaamisen muuttumattoman viitteen kautta.

Cell<T>: Copy-tyypeille; korvaa sisällä olevan arvon.
RefCell<T>: tyypeille, jotka eivät toteuta Copy-traitia; tarjoaa suorituksen aikana tarkistettavat muunneltavat ja muuttumattomat viitteet.
RefCell-tyypin sääntöjen rikkominen aiheuttaa suorituksen aikaisen paniikin, mikä varmistaa turvallisuuden.

Nämä tyypit ovat tärkeitä esimerkiksi mock-objektien ja kehäviittausten toteuttamisessa sekä tilanteissa, joissa jaetun muuttumattoman viitteen täytyy seurata sisäistä tilaa.

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 ”Sisäinen muokattavuus: RefCell ja Cell” ilmainen?

Kyllä — voit lukea täällä verkossa kokonaan ilmaiseksi mitkä tahansa Rust-ohjelmoinnin perusteet-oppimispolun 3 oppituntia, myös oppitunnin “Sisäinen muokattavuus: RefCell ja Cell”. 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ä 3 oppituntia.

Mitä opin oppitunnilla ”Sisäinen muokattavuus: RefCell ja Cell”?

Tutustutte `RefCell`- ja `Cell`-tyyppeihin sisäisen muokattavuuden toteuttamiseksi eli tietojen turvalliseen muuttamiseen muuttumattoman viitteen kautta. 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/3.

Kuinka kauan ”Sisäinen muokattavuus: RefCell ja Cell”-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