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

Размерный знаковый целочисленный тип.

Размер этого примитива соответствует количеству байт, необходимых для ссылки на любое место в памяти. Например, на 32-битной цели это 4 байта, а на 64-битной — 8 байтов.

Примечание: В данной документации представлены реализации для 64-битной архитектуры. На 32-битной архитектуре значения констант и поведение методов будут отличаться.

Константы

Константа	Значение	Версия	Описание
`MIN`	`-9_223_372_036_854_775_808`	1.43.0	Наименьшее значение (−2⁶³)
`MAX`	`9_223_372_036_854_775_807`	1.43.0	Наибольшее значение (2⁶³ − 1)
`BITS`	`64`	1.53.0	Размер типа в битах

Таблицы методов

Битовая арифметика

Метод	Версия	Описание
`count_ones()`	1.0.0	Количество единиц в двоичном представлении
`count_zeros()`	1.0.0	Количество нулей в двоичном представлении
`leading_zeros()`	1.0.0	Количество ведущих нулей
`trailing_zeros()`	1.0.0	Количество хвостовых нулей
`leading_ones()`	1.46.0	Количество ведущих единиц
`trailing_ones()`	1.46.0	Количество хвостовых единиц
`rotate_left(n)`	1.0.0	Циклический сдвиг влево
`rotate_right(n)`	1.0.0	Циклический сдвиг вправо
`swap_bytes()`	1.0.0	Обратный порядок байтов
`reverse_bits()`	1.37.0	Обратный порядок битов
`from_be(x)`	1.0.0	Преобразование из big-endian
`from_le(x)`	1.0.0	Преобразование из little-endian
`to_be()`	1.0.0	Преобразование в big-endian
`to_le()`	1.0.0	Преобразование в little-endian
`cast_unsigned()`	1.87.0	Преобразование битового шаблона в usize

Экспериментальные битовые методы

Метод	Флаг	Описание
`isolate_highest_one()`	`isolate_most_least_significant_one`	Оставляет только старший бит
`isolate_lowest_one()`	`isolate_most_least_significant_one`	Оставляет только младший бит
`highest_one()`	`int_lowest_highest_one`	Индекс старшего установленного бита
`lowest_one()`	`int_lowest_highest_one`	Индекс младшего установленного бита
`shl_exact(rhs)`	`exact_bitshifts`	Точный сдвиг влево с проверкой
`shr_exact(rhs)`	`exact_bitshifts`	Точный сдвиг вправо с проверкой
`div_exact(rhs)`	`exact_div`	Деление без остатка
`checked_div_exact(rhs)`	`exact_div`	Проверенное деление без остатка

Арифметика с проверкой переполнения

Метод	Операция	Версия	Поведение при переполнении
`checked_add(rhs)`	`+`	1.0.0	Возвращает `None`
`checked_sub(rhs)`	`-`	1.0.0	Возвращает `None`
`checked_mul(rhs)`	`*`	1.0.0	Возвращает `None`
`checked_div(rhs)`	`/`	1.0.0	Возвращает `None` при делении на 0 или переполнении
`checked_rem(rhs)`	`%`	1.7.0	Возвращает `None` при делении на 0 или переполнении
`checked_neg()`	`-x`	1.7.0	Возвращает `None` для `MIN`
`checked_shl(rhs)`	`<<`	1.7.0	Возвращает `None` при слишком большом сдвиге
`checked_shr(rhs)`	`>>`	1.7.0	Возвращает `None` при слишком большом сдвиге
`checked_abs()`	`abs()`	1.13.0	Возвращает `None` для `MIN`
`checked_pow(exp)`	`pow()`	1.34.0	Возвращает `None` при переполнении
`checked_isqrt()`	`isqrt()`	1.84.0	Возвращает `None` для отрицательных чисел

Строгие методы (всегда паникуют при переполнении)

Метод	Версия	Паникует при
`strict_add(rhs)`	1.91.0	Переполнении
`strict_sub(rhs)`	1.91.0	Переполнении
`strict_mul(rhs)`	1.91.0	Переполнении
`strict_div(rhs)`	1.91.0	Делении на 0 или `MIN / -1`
`strict_rem(rhs)`	1.91.0	Делении на 0 или `MIN % -1`
`strict_neg()`	1.91.0	`-MIN`
`strict_shl(rhs)`	1.91.0	Сдвиге ≥ BITS
`strict_shr(rhs)`	1.91.0	Сдвиге ≥ BITS
`strict_abs()`	1.91.0	`abs(MIN)`
`strict_pow(exp)`	1.91.0	Переполнении

Небезопасные методы (без проверок)

Метод	Флаг	Небезопасность при
`unchecked_add(rhs)`	-	Переполнении
`unchecked_sub(rhs)`	-	Переполнении
`unchecked_mul(rhs)`	-	Переполнении
`unchecked_neg()`	`unchecked_neg`	`-MIN`
`unchecked_shl(rhs)`	`unchecked_shifts`	Сдвиге ≥ BITS
`unchecked_shr(rhs)`	`unchecked_shifts`	Сдвиге ≥ BITS
`unchecked_shl_exact(rhs)`	`exact_bitshifts`	Невозможности обратить сдвиг
`unchecked_shr_exact(rhs)`	`exact_bitshifts`	Невозможности обратить сдвиг
`unchecked_div_exact(rhs)`	`exact_div`	Делении на 0, остатке или `MIN / -1`

Насыщающая арифметика

Метод	Операция	Версия	Поведение при переполнении
`saturating_add(rhs)`	`+`	1.0.0	Возвращает `MAX` или `MIN`
`saturating_sub(rhs)`	`-`	1.0.0	Возвращает `MAX` или `MIN`
`saturating_mul(rhs)`	`*`	1.7.0	Возвращает `MAX` или `MIN`
`saturating_div(rhs)`	`/`	1.58.0	Возвращает `MAX` или `MIN`
`saturating_neg()`	`-x`	1.45.0	Возвращает `MAX` для `MIN`
`saturating_abs()`	`abs()`	1.45.0	Возвращает `MAX` для `MIN`
`saturating_pow(exp)`	`pow()`	1.34.0	Возвращает `MAX` или `MIN`

Обёртывающая арифметика

Метод	Операция	Версия	Поведение при переполнении
`wrapping_add(rhs)`	`+`	1.0.0	Обёртывание по модулю
`wrapping_sub(rhs)`	`-`	1.0.0	Обёртывание по модулю
`wrapping_mul(rhs)`	`*`	1.0.0	Обёртывание по модулю
`wrapping_div(rhs)`	`/`	1.2.0	Возвращает `MIN` для `MIN / -1`
`wrapping_rem(rhs)`	`%`	1.2.0	Возвращает 0 для `MIN % -1`
`wrapping_neg()`	`-x`	1.2.0	Возвращает `MIN` для `MIN`
`wrapping_shl(rhs)`	`<<`	1.2.0	Маскирование сдвига
`wrapping_shr(rhs)`	`>>`	1.2.0	Маскирование сдвига
`wrapping_abs()`	`abs()`	1.13.0	Возвращает `MIN` для `MIN`
`wrapping_pow(exp)`	`pow()`	1.34.0	Обёртывание по модулю

Арифметика с переполнением (возвращает флаг)

Метод	Операция	Версия	Возвращает
`overflowing_add(rhs)`	`+`	1.7.0	`(результат, флаг_переполнения)`
`overflowing_sub(rhs)`	`-`	1.7.0	`(результат, флаг_переполнения)`
`overflowing_mul(rhs)`	`*`	1.7.0	`(результат, флаг_переполнения)`
`overflowing_div(rhs)`	`/`	1.7.0	`(результат, флаг_переполнения)`
`overflowing_rem(rhs)`	`%`	1.7.0	`(результат, флаг_переполнения)`
`overflowing_neg()`	`-x`	1.7.0	`(результат, флаг_переполнения)`
`overflowing_shl(rhs)`	`<<`	1.7.0	`(результат, флаг_сдвига)`
`overflowing_shr(rhs)`	`>>`	1.7.0	`(результат, флаг_сдвига)`
`overflowing_abs()`	`abs()`	1.13.0	`(результат, флаг_переполнения)`
`overflowing_pow(exp)`	`pow()`	1.34.0	`(результат, флаг_переполнения)`

Работа с беззнаковыми числами

Метод	Операция	Версия	Тип аргумента
`checked_add_unsigned(rhs)`	`+`	1.66.0	`usize`
`checked_sub_unsigned(rhs)`	`-`	1.66.0	`usize`
`strict_add_unsigned(rhs)`	`+`	1.91.0	`usize`
`strict_sub_unsigned(rhs)`	`-`	1.91.0	`usize`
`saturating_add_unsigned(rhs)`	`+`	1.66.0	`usize`
`saturating_sub_unsigned(rhs)`	`-`	1.66.0	`usize`
`wrapping_add_unsigned(rhs)`	`+`	1.66.0	`usize`
`wrapping_sub_unsigned(rhs)`	`-`	1.66.0	`usize`
`overflowing_add_unsigned(rhs)`	`+`	1.66.0	`usize`
`overflowing_sub_unsigned(rhs)`	`-`	1.66.0	`usize`

Евклидова арифметика

Метод	Версия	Описание
`div_euclid(rhs)`	1.38.0	Евклидово деление
`rem_euclid(rhs)`	1.38.0	Евклидов остаток
`checked_div_euclid(rhs)`	1.38.0	Проверенное евклидово деление
`checked_rem_euclid(rhs)`	1.38.0	Проверенный евклидов остаток
`strict_div_euclid(rhs)`	1.91.0	Строгое евклидово деление
`strict_rem_euclid(rhs)`	1.91.0	Строгий евклидов остаток
`wrapping_div_euclid(rhs)`	1.38.0	Обёртывающее евклидово деление
`wrapping_rem_euclid(rhs)`	1.38.0	Обёртывающий евклидов остаток
`overflowing_div_euclid(rhs)`	1.38.0	Евклидово деление с переполнением
`overflowing_rem_euclid(rhs)`	1.38.0	Евклидов остаток с переполнением

Устаревшие методы

Метод	Замена	Версия	Статус
`min_value()`	`MIN`	1.0.0	Устарел
`max_value()`	`MAX`	1.0.0	Устарел

Математические функции

Метод	Описание	Версия
`abs()`	Абсолютное значение	1.0.0
`signum()`	Знак числа	1.0.0
`is_positive()`	Проверка положительности	1.0.0
`is_negative()`	Проверка отрицательности	1.0.0
`pow(exp)`	Возведение в степень	1.0.0
`isqrt()`	Целочисленный квадратный корень	1.84.0
`ilog(base)`	Логарифм по произвольному основанию	1.67.0
`ilog2()`	Двоичный логарифм	1.67.0
`ilog10()`	Десятичный логарифм	1.67.0
`checked_ilog(base)`	Проверенный логарифм	1.67.0
`checked_ilog2()`	Проверенный двоичный логарифм	1.67.0
`checked_ilog10()`	Проверенный десятичный логарифм	1.67.0
`unsigned_abs()`	Беззнаковое абсолютное значение	1.51.0
`abs_diff(other)`	Абсолютная разница	1.60.0
`midpoint(rhs)`	Средняя точка	1.87.0

Округление деления

Метод	Флаг	Описание
`div_floor(rhs)`	`int_roundings`	Деление с округлением вниз
`div_ceil(rhs)`	`int_roundings`	Деление с округлением вверх
`next_multiple_of(rhs)`	`int_roundings`	Следующее кратное
`checked_next_multiple_of(rhs)`	`int_roundings`	Проверенное следующее кратное

Расширенная арифметика (для больших чисел)

Метод	Флаг	Описание
`carrying_add(rhs, carry)`	`bigint_helper_methods`	Сложение с переносом
`borrowing_sub(rhs, borrow)`	`bigint_helper_methods`	Вычитание с заёмом
`widening_mul(rhs)`	`bigint_helper_methods`	Расширенное умножение
`carrying_mul(rhs, carry)`	`bigint_helper_methods`	Умножение с переносом
`carrying_mul_add(rhs, carry, add)`	`bigint_helper_methods`	Умножение с переносом и сложением

Работа с байтами

Метод	Порядок байтов	Версия	Возвращает
`to_be_bytes()`	Big-endian	1.32.0	`[u8; 8]`
`to_le_bytes()`	Little-endian	1.32.0	`[u8; 8]`
`to_ne_bytes()`	Native	1.32.0	`[u8; 8]`
`from_be_bytes(bytes)`	Big-endian	1.32.0	`isize`
`from_le_bytes(bytes)`	Little-endian	1.32.0	`isize`
`from_ne_bytes(bytes)`	Native	1.32.0	`isize`

Парсинг строк

Метод	Источник	Версия
`from_str_radix(src, radix)`	`&str`	1.0.0
`from_ascii(src)`	`&[u8]`	nightly
`from_ascii_radix(src, radix)`	`&[u8]`	nightly
`from_str(src)` (impl `FromStr`)	`&str`	1.0.0

Форматирование

Метод	Флаг	Описание
`format_into(buf)`	`int_format_into`	Форматирование в буфер

Специальные методы сдвига

Метод	Версия	Описание
`unbounded_shl(rhs)`	1.87.0	Сдвиг влево без ограничений
`unbounded_shr(rhs)`	1.87.0	Сдвиг вправо без ограничений

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

Арифметические операторы

Трейт	Операция	Реализация
`Add`, `AddAssign`	`+`, `+=`	Сложение
`Sub`, `SubAssign`	`-`, `-=`	Вычитание
`Mul`, `MulAssign`	``, `=`	Умножение
`Div`, `DivAssign`	`/`, `/=`	Деление
`Rem`, `RemAssign`	`%`, `%=`	Остаток
`Neg`	`-x`	Отрицание
`BitAnd`, `BitAndAssign`	`&`, `&=`	Побитовое И
`BitOr`, `BitOrAssign`	`	`,`
`BitXor`, `BitXorAssign`	`^`, `^=`	Побитовое XOR
`Not`	`!`	Побитовое НЕ
`Shl`, `ShlAssign`	`<<`, `<<=`	Сдвиг влево
`Shr`, `ShrAssign`	`>>`, `>>=`	Сдвиг вправо

Трейты форматирования

Трейт	Формат	Пример
`Display`	Десятичный	`42`
`Debug`	Отладочный	`42`
`Binary`	Двоичный	`0b101010`
`Octal`	Восьмеричный	`0o52`
`LowerHex`	Нижний регистр hex	`0x2a`
`UpperHex`	Верхний регистр hex	`0x2A`
`LowerExp`	Научная нотация (нижний)	`4.2e1`
`UpperExp`	Научная нотация (верхний)	`4.2E1`

Трейты преобразования

Преобразование	Метод	Особенности
`From<bool>`	`from(bool)`	0 для false, 1 для true
`From<i8>`	`from(i8)`	Без потерь
`From<i16>`	`from(i16)`	Без потерь
`From<u8>`	`from(u8)`	Без потерь
`TryFrom<i32>`	`try_from(i32)`	С проверкой диапазона
`TryFrom<i64>`	`try_from(i64)`	С проверкой диапазона
`TryFrom<i128>`	`try_from(i128)`	С проверкой диапазона
`TryFrom<u16>`	`try_from(u16)`	С проверкой диапазона
`TryFrom<u32>`	`try_from(u32)`	С проверкой диапазона
`TryFrom<u64>`	`try_from(u64)`	С проверкой диапазона
`TryFrom<u128>`	`try_from(u128)`	С проверкой диапазона
`TryFrom<usize>`	`try_from(usize)`	С проверкой диапазона

Прочие важные трейты

Трейт	Назначение
`Default`	Значение по умолчанию (0)
`Clone`, `Copy`	Клонирование и копирование
`Hash`	Хеширование
`PartialOrd`, `Ord`	Сравнение
`PartialEq`, `Eq`	Равенство
`Step`, `TrustedStep`	Итерация по диапазонам
`Product`, `Sum`	Агрегация итераторов
`FromStr`	Парсинг из строки

Примеры

Базовое использование

#![allow(unused)]
fn main() {
let x: isize = 42;
let y: isize = -10;

assert_eq!(x + y, 32);
assert_eq!(x.abs_diff(y), 52);
}

Проверка переполнения

#![allow(unused)]
fn main() {
assert_eq!(isize::MAX.checked_add(1), None);
assert_eq!(isize::MAX.saturating_add(1), isize::MAX);
assert_eq!(isize::MAX.wrapping_add(1), isize::MIN);
}

Работа с битами

#![allow(unused)]
fn main() {
let n: isize = 0b1010;
assert_eq!(n.count_ones(), 2);
assert_eq!(n.rotate_left(2), 0b101000);
}

Преобразование байтов

#![allow(unused)]
fn main() {
let bytes = 0x1234567890123456isize.to_be_bytes();
assert_eq!(bytes, [0x12, 0x34, 0x56, 0x78, 0x90, 0x12, 0x34, 0x56]);

let value = isize::from_be_bytes(bytes);
assert_eq!(value, 0x1234567890123456);
}

Евклидова арифметика

#![allow(unused)]
fn main() {
let a: isize = -7;
let b: isize = 4;
assert_eq!(a.div_euclid(b), -2);
assert_eq!(a.rem_euclid(b), 1);
}

Логарифмы

#![allow(unused)]
fn main() {
assert_eq!(16isize.ilog2(), 4);
assert_eq!(100isize.ilog10(), 2);
assert_eq!(125isize.ilog(5), 3);
}

Особенности

Размерность: Размер isize зависит от целевой архитектуры (обычно 32 или 64 бита).
Переполнение: При переполнении в отладочной сборке происходит паника, в релизной — обёртывание.
Деление на ноль: Всегда вызывает панику.
MIN.abs(): Вызывает панику в отладочной сборке, возвращает MIN в релизной.
Эндрианность: Методы to_be_bytes(), to_le_bytes(), to_ne_bytes() учитывают порядок байтов.

Библиотека RUST