Learn Rust Coding · Lekcja

Zrozumienie modelu własności w Rust

Poznają Państwo podstawowe zasady własności i semantykę przenoszenia oraz dowiedzą się, jak zapobiegają typowym błędom pamięci, takim jak double-free.

Zrozumienie modelu własności w Rust to bezpłatna lekcja Learn Rust Coding na CoddyKit. To lekcja 1 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 jest własność w języku Rust?

System własności w języku Rust to zbiór reguł zarządzających sposobem korzystania z pamięci przez program. Jest to kluczowa koncepcja, która pozwala osiągnąć bezpieczeństwo pamięci bez garbage collectora.

Brak wiszących wskaźników.
Brak błędów podwójnego zwalniania pamięci.
Brak wyścigów danych w kodzie współbieżnym.

Reguły te są sprawdzane podczas kompilacji!

Pamięć stosu a pamięć sterty

Programy korzystają z dwóch głównych obszarów pamięci: stosu i sterty.

Stos: Szybsze dane o stałym rozmiarze (takie jak liczby całkowite, wartości logiczne i typy o znanym rozmiarze). Dane są odkładane i zdejmowane w określonej kolejności.
Sterta: Wolniejsze dane o zmiennym rozmiarze (takie jak String i Vec). Dane są przydzielane i zwalniane przez alokator.

Własność zarządza przede wszystkim danymi na stercie, zapewniając ich bezpieczne używanie i zwalnianie.

Reguła 1: każda wartość ma właściciela

Pierwsza reguła własności jest prosta: każda wartość w języku Rust ma zmienną nazywaną jej właścicielem.

Można wyobrazić to sobie jako etykietę na pudełku. Zmienna s poniżej jest właścicielem tekstu "hello".

fn main() {
  let s = String::from("hello"); // s owns "hello"
  println!("{}", s);
}

Reguła 2: w danym momencie jest tylko jeden właściciel

Druga reguła mówi: w dowolnym momencie dana wartość może mieć tylko jednego właściciela. Ma to kluczowe znaczenie dla zapobiegania problemom z pamięcią.

Gdy złożona wartość (taka jak String, która znajduje się na stercie) zostaje przypisana z jednej zmiennej do drugiej, własność jest przenoszona, a nie kopiowana.

Przenoszenie własności w praktyce

Zobacz, co dzieje się, gdy wartość s1 zostaje przypisana do s2. Spróbuj uruchomić kod.

fn main() {
  let s1 = String::from("Hello, CoddyKit!");
  let s2 = s1; // Ownership of the String data moves from s1 to s2

  // println!("{}", s1); // This line would cause a compile-time error!
  println!("{}", s2);
}

Zrozumienie semantyki „przenoszenia”

Po wykonaniu let s2 = s1; zmienna s1 nie jest już uznawana za prawidłową. Rust uniemożliwia ponowne użycie s1.

Nazywa się to przeniesieniem. Wskaźnik, długość i pojemność na stosie są kopiowane, ale same dane na stercie nie.
Gdyby s1 nadal była prawidłowa, zarówno s1, jak i s2 próbowałyby zwolnić tę samą pamięć po wyjściu poza zakres (błąd podwójnego zwolnienia pamięci).

System własności w języku Rust zapobiega temu już podczas kompilacji!

Własność a wywoływanie funkcji

Przekazanie wartości do funkcji działa podobnie jak przypisanie jej do innej zmiennej: własność zostaje przeniesiona do funkcji.

Po zakończeniu działania funkcji właściciel wartości (parametr funkcji) wychodzi poza zakres, a wartość zostaje usunięta.

Prezentacja własności w funkcjach

Obserwuj, jak wartość String zostaje przeniesiona do takes_ownership, a następnie gives_ownership zwraca nową wartość String.

fn takes_ownership(some_string: String) {
  println!("Inside takes_ownership: {}", some_string);
} // some_string goes out of scope and `drop` is called.

fn gives_ownership() -> String {
  let some_string = String::from("returned string");
  some_string // Ownership is moved out of the function
}

fn main() {
  let s1 = String::from("hello");
  takes_ownership(s1); // s1's value moves into takes_ownership
  // println!("{}", s1); // Error: s1 is no longer valid here!

  let s2 = gives_ownership(); // s2 gets ownership of the returned String
  println!("After gives_ownership: {}", s2);
}

Reguła 3: zakres i usuwanie wartości

Ostatnia reguła mówi: gdy właściciel wychodzi poza zakres, wartość zostaje usunięta.

Zakres to fragment programu, w którym element jest prawidłowy; zwykle wyznaczają go nawiasy klamrowe {}.
Gdy zmienna wychodzi poza zakres, Rust automatycznie wywołuje specjalną funkcję o nazwie drop.

Dzięki temu pamięć jest automatycznie i bezpiecznie zwalniana bez użycia garbage collectora.

Zapobieganie błędom pamięci

Reguły własności współdziałają, aby zagwarantować bezpieczeństwo pamięci:

Jeden właściciel: Zapobiega próbom zwolnienia tej samej pamięci przez różne części kodu.
Usuwanie po wyjściu poza zakres: Zapewnia zwolnienie pamięci dokładnie raz i we właściwym momencie.

Eliminuje to podczas kompilacji typowe błędy, takie jak podwójne zwolnienie pamięci i użycie pamięci po jej zwolnieniu, zapewniając spokój!

Sprawdzenie własności

Proszę przeanalizować poniższy kod w języku Rust. Co się stanie podczas próby jego skompilowania i uruchomienia?

fn main() {
  let message = String::from("Rust is fun!");
  let greeting = message;
  println!("{}", message);
}

Podsumowanie: podstawy własności

Świetnie! Poznali Państwo podstawowe reguły systemu własności w języku Rust:

Każda wartość ma właściciela.
W danym momencie może istnieć tylko jeden właściciel.
Gdy właściciel wychodzi poza zakres, wartość zostaje usunięta.

System ten zapobiega typowym błędom pamięci bez użycia garbage collectora. Następnie poznamy pożyczanie, które umożliwia współdzielenie danych bez przenoszenia własności.

Często zadawane pytania

Czy lekcja „Zrozumienie modelu własności w Rust” jest bezpłatna?

Tak — pełny tekst „Zrozumienie modelu własności w Rust” 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 „Zrozumienie modelu własności w Rust”?

Poznają Państwo podstawowe zasady własności i semantykę przenoszenia oraz dowiedzą się, jak zapobiegają typowym błędom pamięci, takim jak double-free. Ć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 1 z 3.

Ile czasu zajmuje lekcja „Zrozumienie modelu własności w Rust”?

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