Продолжаем изучать Rust нетрадиционным способом. В этом раз будем разбираться в нюансах работы с кучей, для их понимания понадобятся: сырые указатели, выделение памяти в куче, размер экземпляра типа, запись значений в кучу и чтение из нее, const и static, unit-like структуры, переопределение глобального аллокатора.

Это, определенно, overkill для одной статьи, а вот половину списка вполне можно освоить.

• Предыдущая часть: Времена и структуры
• Начало и содержание: Владение

Сырые указатели (Raw Pointers)

Указатель на неизменяемое значение:

    let i: i32 = 10;
    let pi = &i as *const i32;
    unsafe {
        dbg!(*pi);
    }

Указатель на изменяемое значение:

    let mut i: i32 = 10;
    let p_i = &mut i as *mut i32;
    unsafe {
        *p_i = 20;
        println!("*p_i: {}", *p_i)
    }

Против правил:

    let i: i32 = 0x_10_20_30_40;    
    let p_i = &i as *const _ as *mut i16;
    unsafe{
         *p_i = 0x_70_80;
         *p_i.offset(1) = 0x_50_60;
    }
    println!("i: {:x}", i);

• Брать адреса можно сколько угодно, а вот разыменование указателя — опасная затея, так что добро пожаловать на территорию unsafe{}
• Для ряда случаев, например, при нестандартном выравнивании или работой с неинициализированной памятью, надо использовать ptr::addr_of!() / ptr::addr_of_mut!()
• Документация по методам сырых указателей: primitive.pointer

Выделение и освобождение памяти

Через std::alloc::alloc(), std::alloc::dealloc():

#[derive(Debug)]
struct Point {
    x: i32,
    y: i32,
}

fn main(){
    let ppoint = alloc_t::<Point>();

    unsafe {
        (*ppoint).x = 10;
        (*ppoint).y = 20;
        println!("*ppoint: {:?}", *ppoint);
    }

    dealloc_t(ppoint);
}
fn alloc_t<T> () -> * mut T{
    let layout = std::alloc::Layout::new::<T>();
    unsafe {
        let res = std::alloc::alloc(layout) as *mut T;
        if res.is_null() {
            std::alloc::handle_alloc_error(layout);
        }
        return res;
    }
}
fn dealloc_t<T> (p: *mut T) {
    let layout = std::alloc::Layout::new::<T>();
    unsafe {
        std::alloc::dealloc(p as *mut u8, layout);
    }
}

• Пара alloc()/dealloc() указана в The Rustonomicon при разборе RawVec
• Nomicon то ли отстает, то ли упрощает (в смысле, указанная пара уже не используется)
• Как обстоят дела на самом деле с RawVec, рассмотрим позже, для этого нужны неведомые пока (в рамках серии статей) конструкции языка
• Вызов handle_alloc_error — рекомендованный ("...are encouraged to call this function") способ обработки ошибок выделения памяти
• handle_alloc_error() имеет сигнатуру pub fn handle_alloc_error(layout: Layout) -> ! — "фатальная" функция, из таких не возвращаются

См. также:

• Вариант через обычный malloc

Размер экземпляра типа

Научившись выделять память полезно понимать, на что она пойдет. По отношению к размеру типы бывают:

1. Sized Types. Их размер известен во время компиляции и можно создать экземпляр типа. Несколько примеров, где размер экземпляра больше нуля:

...
    dbg!(mem::size_of::<bool>());
    dbg!(mem::align_of::<bool>());
    dbg!(mem::size_of::<[i32; 50]>());
    dbg!(mem::align_of::<[i32; 50]>());
    dbg!(mem::size_of::<PointTuple>());
    dbg!(mem::align_of::<PointTuple>());
...    

Пора сказать пару слов про кортеж (tuple). Это структура с безымянными полями:

#[derive(Debug)]
struct PointTuple(i32, i32);

fn main() {
    let mut pt = PointTuple(10, 20);
    pt.0 = 100;
    pt.1 = 200;
    dbg!(pt);
}

2. Zero Sized Types (ZST). Подмножество Sized, размер экземпляра типа равен нулю, но все еще можно его создать.

К ZST относятся:

• Пустые структуры
• Unit-like структуры
• Пустые кортежи
• Пустые массивы

!!! Подавать layout таких типов в функции выделения памяти категорически нельзя

Ну т.е. можно, но результатом будет undefined behavior.

3. Empty Types. Экзотические типы, экземпляров которых не существует.

Пустой enum:

enum ZeroVariants {}

NeverType (на текущий момент тип не "стабилизирован"):

let x: ! = panic!();

4. Dynamically Sized Types (DSTs). Размер таких типов неизвестен во время компиляции:

• интерфейсы (traits);
• срезы (slices): [T], str.

Rust не примет такую запись:

let s1: str = "Hello there!";

Интересный вопрос — почему, ведь можно посчитать размер памяти, которая требуется для "Hello there!"? Есть требование, что все экземпляры Sized-типа должны иметь одинаковый размер, вот ему-то значения str и не соответствуют (т.е. единого размера нет), так что — &str и DST.

Далее, если интересно, см.:

• The Rustonomicon::Exotically Sized Types
• The Rust Reference::Type Layout

Запись / чтение

Теперь у нас все готово для того, чтобы отправлять переменные в Сумрак и выводить обратно.

Туда:

    let ppoint = alloc_t::<Point>();

    // Write to heap
    {
        let p = Point{x: 101, y:201};
        unsafe {ppoint.write(p)}
        println!("ppoint.write() completed");
    }

• Важно: Деструктор для p при этом НЕ вызывается, т.е. Rust в глубинах вызова как бы "забывает" про эту переменную (текущая последовательность: раз, два).

Обратно:

    // Read from heap
    {
        let p;
        unsafe { p = ppoint.read()}
        println!("ppoint.read() completed: {:?}", p);
    }

Для того чтобы посмотреть, когда же вызывается деструктор, реализуем Drop для Point:

impl Drop for Point {
    fn drop(&mut self) {
        println!("Point dropped: {:?}", self);
    }
}

Все вместе при запуске дает результат:

ppoint.write() completed
ppoint.read() completed: Point { x: 101, y: 201 }
Point dropped: Point { x: 101, y: 201 }

Т.е. сначала записываем, затем читаем, и только потом вызывается деструктор у прочитанного значения.

Еще немного — и с кучей завершим.

Далее: Заменяем глобальный аллокатор