Примитивный тип pointer

Сырые указатели (raw pointers) *const T и *mut T

Смотрите также модуль std::ptr.

Работа с сырыми указателями в Rust встречается редко и обычно ограничена несколькими паттернами. Сырые указатели могут быть:

• Выходящими за границы (out-of-bounds)
• Невыровненными (unaligned)
• Нулевыми (null)

Однако при загрузке из или записи в сырой указатель он должен быть валидным для данного доступа и выровненным. При использовании выражений доступа к полю, индексации кортежа, массива или среза на сыром указателе применяются правила арифметики указателей в пределах границ.

Запись через сырой указатель с помощью *ptr = data вызывает drop на старом значении, поэтому если тип имеет деструктор (drop glue) и память ещё не инициализирована, необходимо использовать write - иначе drop будет вызван на неинициализированной памяти.

Используйте функции null и null_mut для создания нулевых указателей, а метод is_null типов *const T и *mut T для проверки на null. Типы *const T и *mut T также определяют метод offset для арифметики указателей.

---

Распространённые способы создания сырых указателей

1. Приведение ссылки (&T) или изменяемой ссылки (&mut T)

#![allow(unused)]
fn main() {
let my_num: i32 = 10;
let my_num_ptr: *const i32 = &my_num;
let mut my_speed: i32 = 88;
let my_speed_ptr: *mut i32 = &mut my_speed;
}

Чтобы получить указатель на упакованное значение (Box), разыменуйте box:

#![allow(unused)]
fn main() {
let my_num: Box<i32> = Box::new(10);
let my_num_ptr: *const i32 = &*my_num;
let mut my_speed: Box<i32> = Box::new(88);
let my_speed_ptr: *mut i32 = &mut *my_speed;
}

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

2. Потребление box'а (Box<T>)

Функция into_raw потребляет box и возвращает сырой указатель. Она не уничтожает T и не освобождает память.

#![allow(unused)]
fn main() {
let my_speed: Box<i32> = Box::new(88);
let my_speed: *mut i32 = Box::into_raw(my_speed);

// Забрав владение исходным `Box<T>`, мы обязаны позже собрать его для уничтожения
unsafe {
    drop(Box::from_raw(my_speed));
}
}

Примечание: вызов drop здесь для ясности - он указывает, что мы закончили работу с данным значением и его следует уничтожить.

3. Создание с помощью &raw

Вместо приведения ссылки к сырому указателю можно использовать операторы сырого заимствования &raw const (для *const T) и &raw mut (для *mut T). Эти операторы позволяют создавать сырые указатели на поля, на которые нельзя создать ссылку (без возникновения неопределённого поведения), например, на невыровненное поле. Это может быть необходимо при работе с упакованными структурами (packed structs) или неинициализированной памятью.

#![allow(unused)]
fn main() {
#[derive(Debug, Default, Copy, Clone)]
#[repr(C, packed)]
struct S {
    aligned: u8,
    unaligned: u32,
}
let s = S::default();
let p = &raw const s.unaligned; // невозможно с приведением
}

4. Получение из C

#![allow(unused)]
fn main() {
#[allow(unused_extern_crates)]
extern crate libc;

unsafe {
    let my_num: *mut i32 = libc::malloc(size_of::<i32>()) as *mut i32;
    if my_num.is_null() {
        panic!("failed to allocate memory");
    }
    libc::free(my_num as *mut core::ffi::c_void);
}
}

Обычно вы не будете буквально использовать malloc и free из Rust, но C API часто возвращают указатели, поэтому они являются распространённым источником сырых указателей в Rust.

---

Реализации методов

Методы для *const T

Методы для *mut T

Методы для срезов *const [T] и *mut [T]

---

Реализации трейтов

Общие трейты для *const T и *mut T

Специальные трейты

---

Автоматические реализации трейтов

• RefUnwindSafe - реализуется, когда T: RefUnwindSafe + ?Sized

---

Особенности безопасности

1. Большинство операций с сырыми указателями помечены как unsafe - компилятор не может проверить их безопасность.
2. Проверка выравнивания - многие операции требуют правильного выравнивания указателя.
3. Проверка границ - указатели должны оставаться в пределах выделенной памяти.
4. Проверка на null - многие методы имеют варианты с проверкой и без проверки на null.
5. Происхождение (provenance) - современные API (addr, with_addr) учитывают происхождение указателей для строгой модели памяти.

---

Примеры использования

#![allow(unused)]
fn main() {
// Безопасное создание и использование сырых указателей
let x = 42;
let ptr: *const i32 = &x;

unsafe {
    if let Some(val) = ptr.as_ref() {
        assert_eq!(*val, 42);
    }
}

// Арифметика указателей
let arr = [1, 2, 3, 4, 5];
let ptr = arr.as_ptr();

unsafe {
    let ptr2 = ptr.add(2); // Указатель на третий элемент
    assert_eq!(*ptr2, 3);
}

// Работа с изменяемыми указателями
let mut arr = [1, 2, 3];
let ptr = arr.as_mut_ptr();

unsafe {
    *ptr.add(1) = 10; // Изменяем второй элемент
}
assert_eq!(arr, [1, 10, 3]);
}

Важно: Все операции с сырыми указателями требуют тщательного соблюдения правил безопасности Rust, включая проверку выравнивания, границ и времени жизни.