Learn Rust Coding · Lekcja

Wyjaśnienie referencji i pożyczania

Poznają Państwo referencje i pożyczanie, które pozwalają wielu częściom kodu bezpiecznie uzyskiwać dostęp do danych bez przejmowania własności.

Wyjaśnienie referencji i pożyczania to bezpłatna lekcja Learn Rust Coding na CoddyKit. To lekcja 2 z 3. 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 3 lekcji w sumie.

Czym są referencje?

W języku Rust zmienne są właścicielami swoich danych. Co jednak zrobić, gdy inne części kodu muszą odczytać te dane lub nawet je zmodyfikować, ale bez przejmowania własności?

Właśnie do tego służą referencje! Referencja przypomina wskaźnik do wartości, ale podlega ścisłym regułom egzekwowanym przez kompilator języka Rust.

Można myśleć o niej jak o oglądaniu czegoś przez okno zamiast posiadania tego przedmiotu.

Pierwsza referencja

Referencję tworzymy za pomocą operatora &. Tworzy on nieposiadający własności wskaźnik do wartości. Zobaczmy, jak to działa w praktyce:

fn print_length(s: &String) {
  println!("The length is: {}", s.len());
}

fn main() {
  let message = String::from("Hello, CoddyKit!");
  print_length(&message); // Pass a reference
  println!("Original message still here: {}", message);
}

Zrozumienie pożyczania

Gdy tworzysz referencję do wartości, pożyczasz tę wartość. Właściciel nadal jest jej właścicielem, ale zyskujesz tymczasowy dostęp.

Udostępnianie bez oddawania: Możesz używać pożyczonych danych.
Brak przeniesienia własności: Oryginalna zmienna nadal jest właścicielem danych i usunie je po wyjściu poza zakres.
Bezpieczeństwo przede wszystkim: Reguły pożyczania w języku Rust zapobiegają typowym błędom programistycznym, takim jak wyścigi danych.

Niemutowalne pożyczanie: dostęp tylko do odczytu

Domyślnie referencje w języku Rust są niemutowalne. Oznacza to, że można odczytywać dane, na które wskazują, ale nie można ich zmieniać.

To podstawowa funkcja bezpieczeństwa! Jeśli wiele części kodu ma dostęp tylko do odczytu, nie mogą przypadkowo wpływać na swoje dane.

Niemutowalne pożyczanie w praktyce

Funkcja calculate_sum przyjmuje tutaj niemutowalną referencję do wektora. Może odczytywać jego elementy, ale nie może ich dodawać ani usuwać.

fn calculate_sum(numbers: &Vec<i32>) -> i32 {
  let mut total = 0;
  for num in numbers {
    total += num;
  }
  total
}

fn main() {
  let my_numbers = vec![10, 20, 30, 40];
  let sum = calculate_sum(&my_numbers); // Immutable borrow
  println!("The sum is: {}", sum);
  println!("Original vector: {:?}", my_numbers);
}

Mutowalne pożyczanie: zmienianie danych

Czasami trzeba zmodyfikować pożyczone dane. W tym celu używa się mutowalnej referencji, oznaczanej przez &mut.

Mutowalne referencje podlegają kluczowej regule: w danym momencie można mieć tylko jedną mutowalną referencję do określonego fragmentu danych. Zapobiega to wyścigom danych i zapewnia bezpieczeństwo.

Modyfikowanie danych za pomocą &mut

Funkcja add_suffix przyjmuje zmienną referencję do typu String. Może bezpośrednio modyfikować oryginalny obiekt String.

fn add_suffix(text: &mut String) {
  text.push_str(" (modified)");
}

fn main() {
  let mut my_string = String::from("Original text");
  add_suffix(&mut my_string); // Mutable borrow
  println!("Modified string: {}", my_string);
}

Złote zasady pożyczania

Kompilator języka Rust egzekwuje te zasady podczas kompilacji, aby zagwarantować bezpieczeństwo pamięci:

W danym momencie można mieć jedną zmienną referencję do fragmentu danych.
LUB w danym momencie można mieć dowolną liczbę niemutowalnych referencji.
Nie można mieć zmiennej referencji, gdy istnieją aktywne niemutowalne referencje.
Referencje muszą być zawsze prawidłowe (nie mogą żyć dłużej niż dane, na które wskazują).

Zasady te zapobiegają wyścigom danych i zapewniają bezpieczeństwo oraz przewidywalność programów.

Konfliktujące pożyczenia

Ten kod próbuje jednocześnie utworzyć niemutowalną i zmienną referencję do my_value, co narusza zasady pożyczania w Rust. Kod NIE zostanie skompilowany.

Spróbuj go uruchomić i zobacz komunikat błędu kompilatora!

fn main() {
  let mut my_value = 100;

  let r1 = &my_value; // Immutable reference
  let r2 = &mut my_value; // Mutable reference (problem here!)

  println!("r1: {}", r1);
  // println!("r2: {}", r2); // This line would also cause an error if uncommented
}

Sprawdź swoje zrozumienie

Rozważ następujący fragment kodu Rust:

fn process_data(data: &mut Vec<i32>) {
  data.push(4);
}

fn main() {
  let mut numbers = vec![1, 2, 3];
  let first_ref = &numbers[0]; // Line A
  process_data(&mut numbers); // Line B
  println!("First element: {}", first_ref); // Line C
}

Która linia lub które linie spowodują błąd podczas kompilacji z powodu zasad pożyczania w Rust?

Podsumowanie: referencje i pożyczanie

Świetnie! Poznałeś(-aś) podstawy referencji i pożyczania w Rust:

Referencje (&) umożliwiają dostęp do danych bez przejmowania własności.
Pożyczanie to tworzenie referencji, czyli udostępnianie dostępu do danych.
Niemutowalne referencje (&) zapewniają dostęp tylko do odczytu.
Zmienne referencje (&mut) zapewniają dostęp do odczytu i zapisu.
Ścisłe zasady pożyczania w Rust (jedna zmienna referencja LUB wiele niemutowalnych) zapobiegają wyścigom danych i zapewniają bezpieczeństwo pamięci podczas kompilacji.

Te pojęcia są kluczowe przy pisaniu bezpiecznego i wydajnego kodu Rust!

Często zadawane pytania

Czy lekcja „Wyjaśnienie referencji i pożyczania” jest bezpłatna?

Tak — pełny tekst „Wyjaśnienie referencji i pożyczania” 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 3 lekcji w sumie.

Co nauczysz się w „Wyjaśnienie referencji i pożyczania”?

Poznają Państwo referencje i pożyczanie, które pozwalają wielu częściom kodu bezpiecznie uzyskiwać dostęp do danych bez przejmowania własności. Ć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 3.

Ile czasu zajmuje lekcja „Wyjaśnienie referencji i pożyczania”?

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