V dalším článku o jazyce Rust budeme pokračovat v popisu vlastností ukazatelů (pointerů), které sice v Rustu existují, ale jsou používány s mnohem menší frekvencí než například v jazyku C.
1. Přístup ke složkám datové struktury přes ukazatel
2. Změna složek datové struktury ve chvíli, kdy již byla odstraněna z paměti
4. Ukazatelová aritmetika: metoda offset()
5. Přístup mimo prvky pole přes ukazatel
6. Zápis do paměti přes ukazatel
8. Pokus o přístup do paměti přes ukazatel NULL
10. Chování aplikace při přímém přiřazení nové hodnoty do proměnné
11. Chování aplikace při použití operace std::ptr::write()
13. Repositář s demonstračními příklady
Důležité upozornění: tento článek se, podobně jako článek předchozí, zabývá relativně okrajovou částí programovacího jazyka Rust. V praxi byste se s použitím ukazatelů v Rustu neměli setkat příliš často, a to především z toho důvodu, že mnohé vlastnosti ukazatelů jsou nahrazeny jinými prostředky – referencemi, „řezy“ (slice), typem „Box“, typem „Rc“ atd. Na druhou stranu je ovšem dobré znát i temné a nebezpečné zákoutí programovacího jazyka.
Vraťme se k demonstračnímu příkladu, který jsme si ukázali na konci předchozího článku. V tomto příkladu je deklarován datový typ (struktura) Complex, k níž existuje i destruktor. Následně vytvoříme hodnotu tohoto typu a adresu, na níž je hodnota uložena, předáme do ukazatele. V příkladu je dále ukázáno, že k prvkům datové struktury je možné přistupovat i přes ukazatel: (*pointer).real. Přitom je nutné mít na paměti, že v Rustu neexistuje obdoba operátoru – > známého z C a C++:
#[derive(Debug)]
struct Complex {
real: f32,
imag: f32,
}
impl Complex {
fn new(real: f32, imag: f32) -> Complex {
println!("Constructing complex number: {:}+{:}i", real, imag);
Complex{real:real, imag:imag}
}
}
impl Drop for Complex {
fn drop(&mut self) {
println!("Dropping complex number: {:}+{:}i", self.real, self.imag);
}
}
fn main() {
let mut value: Complex = Complex::new(1.0, 2.0);
let pointer: *mut Complex;
pointer = &mut value;
println!("{:?}", value);
unsafe {
println!("{:?}", *pointer);
}
value.real = 10.0;
value.imag = 20.0;
println!("{:?}", value);
unsafe {
println!("{:?}", *pointer);
}
unsafe {
(*pointer).real = 20.0;
(*pointer).imag = 40.0;
}
println!("{:?}", value);
unsafe {
println!("{:?}", *pointer);
}
}
Podívejme se, jaké zprávy se vypíšou při spuštění tohoto příkladu:
Constructing complex number: 1+2i
Complex { real: 1, imag: 2 }
Complex { real: 1, imag: 2 }
Complex { real: 10, imag: 20 }
Complex { real: 10, imag: 20 }
Complex { real: 20, imag: 40 }
Complex { real: 20, imag: 40 }
Dropping complex number: 20+40i
Při použití ukazatelů překladač programovacího jazyka Rust předpokládá, že programátor přesně ví, co dělá, takže se neprovádí prakticky žádné kontroly životnosti/viditelnost proměnných. V následujícím příkladu má proměnná value omezenou živostnost na „svůj“ blok {}, zatímco ukazatel nazvaný pointer k proměnné přistupuje i ve chvíli, kdy již byla opuštěna oblast její platnosti (to bude patrné po spuštění aplikace):
#[derive(Debug)]
struct Complex {
real: f32,
imag: f32,
}
impl Complex {
fn new(real: f32, imag: f32) -> Complex {
println!("Constructing complex number: {:}+{:}i", real, imag);
Complex{real:real, imag:imag}
}
}
impl Drop for Complex {
fn drop(&mut self) {
println!("Dropping complex number: {:}+{:}i", self.real, self.imag);
}
}
fn main() {
let pointer: *mut Complex;
{
let mut value: Complex = Complex::new(1.0, 2.0);
pointer = &mut value;
println!("{:?}", value);
unsafe {
println!("{:?}", *pointer);
}
value.real = 10.0;
value.imag = 20.0;
println!("{:?}", value);
unsafe {
println!("{:?}", *pointer);
}
unsafe {
(*pointer).real = 20.0;
(*pointer).imag = 40.0;
}
println!("{:?}", value);
unsafe {
println!("{:?}", *pointer);
}
}
// !!!
unsafe {
(*pointer).real = -1.1;
(*pointer).imag = -2.2;
println!("{:?}", *pointer);
}
}
Velmi zajímavé věci nastanou při spuštění aplikace. Povšimněte si především toho, že skutečně vypršela oblast viditelnosti proměnné typu Complex a dokonce byl zavolán její destruktor. Teprve poté jsme přes ukazatel zapsali do paměti, která ovšem již proměnné nepatří! V tomto konkrétním případě sice nedošlo k pádu aplikace (což souvisí se způsobem alokace zásobníkových rámců), ale samozřejmě se jedná o sémanticky špatně napsaný program:
Constructing complex number: 1+2i
Complex { real: 1, imag: 2 }
Complex { real: 1, imag: 2 }
Complex { real: 10, imag: 20 }
Complex { real: 10, imag: 20 }
Complex { real: 20, imag: 40 }
Complex { real: 20, imag: 40 }
Dropping complex number: 20+40i
Complex { real: -1.1, imag: -2.2 }
Představte si navíc tento (sémanticky taktéž chybný) příklad, který opět půjde přeložit:
fn get_ptr_to_complex() -> *mut Complex {
let mut value: Complex = Complex::new(1.0, 2.0);
println!("{:?}", value);
return &mut value;
}
U některých typů je možné získat ukazatel na hodnotu daného typu pomocí metody as_ptr(). Z datových typů, s nimiž se často setkáte, se jedná především o řetězce (str) a řezy poli (slice). Vzhledem k tomu, že v naprosté většině případů dokáže překladač Rustu automaticky volat metody pro slice přímo nad zdrojovými poli (pro které je řez vytvořen), je možné metodu as_ptr() volat i pro celé pole:
let array: [i32; 5] = [1, 2, 3, 4, 5];
let pointer: *const i32 = array.as_ptr();
println!("{:?}", array);
Poznámka: ve skutečnosti je řez/slice interně reprezentován právě ukazatelem + počtem prvků.
Oproti programovacímu jazyku C nejsou v Rustu některé operace s ukazateli prováděny přes „klasickou“ ukazatelovou aritmetiku (přičtení offsetu k ukazateli přetíženým operátorem + atd.), ovšem namísto toho je možné použít metodu offset(), která vypočte offset na základě datového typu ukazatele – jinými slovy pokud se jedná o ukazatel na hodnotu typu i8 nebo pole i8, bude offet použit přímo, u typu i32 bude offset vynásoben čtyřmi, protože jeden prvek i32 zabírá v paměti čtyři bajty. Podívejme se na jednoduchý příklad, v němž se vytvoří pole s pěti prvky typu i32 a následně se přistoupí k prvnímu prvku přímo přes ukazatel, dále ke stejnému prvku přes offset (nulový) a poté ke druhému prvku pole:
fn main() {
let array: [i32; 5] = [1, 2, 3, 4, 5];
let pointer: *const i32 = array.as_ptr();
println!("{:?}", array);
unsafe {
println!("{}", *pointer);
println!("{}", *pointer.offset(0));
println!("{}", *pointer.offset(1));
}
}
Po překladu a spuštění by se mělo vypsat:
[1, 2, 3, 4, 5] 1 1 2
Typ ukazatele se odvodí automaticky, takže ho nemusíme explicitně zapisovat:
fn main() {
let array: [i32; 5] = [1, 2, 3, 4, 5];
let pointer = array.as_ptr();
println!("{:?}", array);
unsafe {
println!("{}", *pointer);
println!("{}", *pointer.offset(0));
println!("{}", *pointer.offset(1));
}
}
Ukazatel ovšem můžeme získat například i pro druhý prvek pole, čímž se situace změní, protože offsety budou počítány relativně k tomuto prvku. Zde můžeme použít záporného offsetu k přístupu do předchozího prvku:
fn main() {
let array: [i32; 5] = [1, 2, 3, 4, 5];
let pointer: *const i32 = &array[1] as *const i32;
println!("{:?}", array);
unsafe {
println!("{}", *pointer);
println!("{}", *pointer.offset(-1));
println!("{}", *pointer.offset(1));
}
}
Po překladu a spuštění by se mělo vypsat:
[1, 2, 3, 4, 5] 2 1 3
Pravděpodobně jste si povšimli, že metodu offset() voláme v bloku unsafe. To je vyžadováno překladačem z toho prostého důvodu, že není (a obecně ani nemůže být) prováděna žádná kontrola, jestli přes offset stále přistupujeme k platným adresám či zda je offset zadán špatně. V následujícím programu hned na třech místech přistupujeme do paměti, která nám vlastně nepatří:
fn main() {
let array: [i32; 5] = [1, 2, 3, 4, 5];
let pointer: *const i32 = &array[0] as *const i32;
println!("{:?}", array);
unsafe {
println!("{}", *pointer);
println!("{}", *pointer.offset(1));
// !!!
println!("{}", *pointer.offset(10));
// !!!
println!("{}", *pointer.offset(-1));
// !!!
println!("{}", *pointer.offset(-10));
}
}
V mém případě se program podařilo spustit bez segfaultu (což však není zaručeno), ovšem samozřejmě přečteme pseudonáhodné hodnoty:
[1, 2, 3, 4, 5] 1 2 32678 1808587265 0
Přes metodu offset() získáme vlastně jen jiný ukazatel, takže můžeme provádět i nepřímý zápis. V následujícím příkladu se nejdříve vypíšou původní hodnoty pětiprvkového pole, následně se dva prvky změní, a to nepřímo přes ukazatel a posléze se vypíše nový obsah pole. Samozřejmě i zápis přes ukazatel a výpočet offsetu musí být umístěn v bloku unsafe:
fn main() {
let mut array: [i32; 5] = [1, 2, 3, 4, 5];
let pointer: *mut i32 = array.as_mut_ptr();
println!("{:?}", array);
unsafe {
*pointer = 100;
*pointer.offset(2) = 200;
}
println!("{:?}", array);
}
Příklad výstupu:
[1, 2, 3, 4, 5] [100, 2, 200, 4, 5]
V programovacím jazyku Rust je možné pracovat i s ukazatelem obsahujícím speciální hodnotu NULL. Ta se vytváří jednoduše – funkcí ptr::null() pro ukazatele na konstantní hodnoty popř. funkcí ptr::null_mut() pro ukazatele na hodnoty měnitelné. Použití těchto funkcí je snadné:
use std::ptr;
fn main() {
let pointer: *const i32 = ptr::null();
println!("{:p}", pointer);
}
Příklad výpisu asi skalní céčkaře nepřekvapí:
0x0
Inicializace ukazatele na měnitelnou hodnotu:
use std::ptr;
fn main() {
let pointer: *mut i32 = ptr::null_mut();
println!("{:p}", pointer);
}
Příklad výpisu (skutečně se zde jedná o stejnou adresu), ovšem její typ je odlišný:
0x0
Pokud budeme chtít ukazatel sice inicializovat na hodnotu NULL, ale později adresu změnit, musíme deklarovat měnitelnou (mutable) proměnnou:
use std::ptr;
fn main() {
let mut pointer: *const i32 = ptr::null();
println!("{:p}", pointer);
let value: i32 = 42;
pointer = &value;
println!("{:p}", pointer);
}
Příklad výpisu:
0x0 0x7fff2aab8c1c
Přístup do paměti přes ukazatel nastavený na NULL je sice možný – překladač takovou konstrukci nebude detekovat ani ji nebude hlásit jako chybu – ale na všech moderních 32bitových a 64bitových architekturách vždy dojde k pádu aplikace v runtime (což je asi jediné rozumné chování). Otestování je snadné.
Čtení:
use std::ptr;
fn main() {
let pointer: *const i32 = ptr::null();
println!("{:p}", pointer);
unsafe {
println!("{}", *pointer);
}
}
Jedna z mála možností, jak v Rustu dosáhnout segfaultu:
$ ./test 0x0 Segmentation fault $ echo $? 139
Zápis:
use std::ptr;
fn main() {
let pointer: *mut i32 = ptr::null_mut();
println!("{:p}", pointer);
unsafe {
*pointer = 42;
}
}
Nahlásí se stejná chyba:
$ ./test 0x0 Segmentation fault $ echo $? 139
Další vyloženě nebezpečnou operací je operace představována funkcí std::ptr::write(). Tato funkce provádí zdánlivě banální operaci – zápis nové hodnoty na zadanou adresu:
use std::ptr;
fn main() {
let mut x = 0;
let pointer: *mut i32 = &mut x;
let y = 42;
println!("{:p}", pointer);
println!("{}", x);
unsafe {
ptr::write(pointer, y);
}
println!("{}", x);
}
Ve skutečnosti se však provede jen přepis staré hodnoty hodnotou novou, ale již se neprovede korektní zrušení staré hodnoty: nezavolá se destruktor atd. Proto je nutné tuto operaci použít skutečně jen ve chvíli, kdy víme, co děláme.
Podívejme se nyní, jak se aplikace chová ve chvíli, kdy do proměnné přiřadíme jinou hodnotu (k tomu se vůbec nepoužívají ukazatele):
use std::ptr;
#[derive(Debug)]
struct Complex {
real: f32,
imag: f32,
}
impl Complex {
fn new(real: f32, imag: f32) -> Complex {
println!("Constructing complex number: {:}+{:}i", real, imag);
Complex{real:real, imag:imag}
}
}
impl Drop for Complex {
fn drop(&mut self) {
println!("Dropping complex number: {:}+{:}i", self.real, self.imag);
}
}
fn main() {
let mut value: Complex = Complex::new(1.0, 2.0);
let value2: Complex = Complex::new(100.0, 200.0);
let pointer: *mut Complex = &mut value;
println!("{:p}", pointer);
println!("{:?}", value);
value = value2;
println!("{:p}", pointer);
println!("{:?}", value);
}
Podle očekávání získáme následující výsledek – jsou zkonstruována dvě komplexní čísla a tudíž se taktéž zavolají dva destruktory ve chvíli, kdy končí životnost hodnot:
Constructing complex number: 1+2i
Constructing complex number: 100+200i
0x7fffe54b4658
Complex { real: 1, imag: 2 }
Dropping complex number: 1+2i
0x7fffe54b4658
Complex { real: 100, imag: 200 }
Dropping complex number: 100+200i
Podobně tomu bude ve chvíli, kdy upravíme funkci main() tak, aby se přiřazení provedlo přes ukazatel:
fn main() {
let mut value: Complex = Complex::new(1.0, 2.0);
let value2: Complex = Complex::new(100.0, 200.0);
let pointer: *mut Complex = &mut value;
println!("{:p}", pointer);
println!("{:?}", value);
unsafe {
*pointer = value2;
}
println!("{:p}", pointer);
println!("{:?}", value);
}
Překladač Rustu je v tomto případě dost chytrý na to, aby poznal, že přiřazením v bloku unsafe končí životnost prvního komplexního čísla.
Třetí modifikace příkladu spočívá v použití std::ptr::write() namísto přiřazení:
use std::ptr;
#[derive(Debug)]
struct Complex {
real: f32,
imag: f32,
}
impl Complex {
fn new(real: f32, imag: f32) -> Complex {
println!("Constructing complex number: {:}+{:}i", real, imag);
Complex{real:real, imag:imag}
}
}
impl Drop for Complex {
fn drop(&mut self) {
println!("Dropping complex number: {:}+{:}i", self.real, self.imag);
}
}
fn main() {
let mut value: Complex = Complex::new(1.0, 2.0);
let value2: Complex = Complex::new(100.0, 200.0);
let pointer: *mut Complex = &mut value;
println!("{:p}", pointer);
println!("{:?}", value);
unsafe {
ptr::write(pointer, value2);
}
println!("{:p}", pointer);
println!("{:?}", value);
}
Zde je již chování diametrálně odlišné, neboť se nezavolá destruktor pro první komplexní číslo!
Constructing complex number: 1+2i
Constructing complex number: 100+200i
0x7fff05ac3478
Complex { real: 1, imag: 2 }
0x7fff05ac3478
Complex { real: 100, imag: 200 }
Dropping complex number: 100+200i
Tuto operaci má tedy smysl použít jen v několika ojedinělých případech, kdy přesně víme, že nechceme volat destruktory staré hodnoty.
Jak již bylo naznačeno v úvodní kapitole, používají se ukazatele v Rustu jen v relativně malém množství případů, typicky při nutnosti volání nativních funkcí přes FFI či při implementaci efektivních datových struktur (viz zdrojové kódy pro Vec). Důležitější je pro céčkaře vědět, kdy naopak ukazatele nepoužít, protože Rust nabízí lepší (typicky bezpečnější) řešení:
Všechny dnes popisované demonstrační příklady byly, ostatně podobně jako ve všech předchozích částech tohoto seriálu, uloženy do Git repositáře dostupného na adrese https://github.com/tisnik/presentations. Demonstrační příklady si můžete v případě potřeby stáhnout i jednotlivě bez nutnosti klonovat celý repositář:
