Rust на примерах

println!("Casting: {} -> {} -> {}", decimal, integer, character);

// Когда преобразовывается любое значение в беззнаковый тип T

// std::T::MAX + 1 добавляется или вычитается до тех пор, пока значение

// не будет помещаться в новый тип.

// 1000 поместится в u16

println!("1000 as a u16 is: {}", 1000 as u16);

// 1000 - 256 - 256 - 256 = 232

// Подробнее. Первые 8 младших битов (LSB) сохраняются,

// а старшие биты (MSB) будут усечены.

println!("1000 as a u8 is : {}", 1000 as u8);

// -1 + 256 = 255

println!(" -1 as a u8 is : {}", (-1i8) as u8);

// Для положительных чисел результатом будет остаток от деления

println!("1000 mod 256 is : {}", 1000 % 256);

// Когда значение преобразовывается в знаковый тип,

// побитовый результат будет таким же, как и

// первое преобразование к соответствующему типу без знака. Если старший бит этого значения

// равен 1, то это значение отрицательное.

// За исключением случая, когда значение умещается в тип.

println!(" 128 as a i16 is: {}", 128 as i16);

// 128 as u8 -> 128, дополнительный код которого в 8 битах:

println!(" 128 as a i8 is : {}", 128 as i8);

// повторяем примеры

// 1000 as u8 -> 232

println!("1000 as a i8 is : {}", 1000 as i8);

// и дополнительный код 232 - это -24

println!(" 232 as a i8 is : {}", 232 as i8);

}

הההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההה

XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

Литералы

Числовые литералы могут быть обозначены добавлением типа в качестве суффикса. Например, чтобы указать, что литерал 42 должен иметь тип i32, необходимо написать 42i32.

Тип литералов без суффикса будет зависеть от того, как они используются. Если нет никаких ограничений, то компилятор будет использовать i32 для целочисленных литералов, а f64 для литералов с плавающей точкой.

fn main() {

// Литералы с суффиксами. Их тип известен при инициализации.

let x = 1u8;

let y = 2u32;

let z = 3f32;

// Литералы без суффиксов. Их тип будет зависеть от того, как их используют.

let i = 1;

let f = 1.0;

// `size_of_val` возвращает размер переменной в байтах

println!("size of `x` in bytes: {}", std::mem::size_of_val(&x));

println!("size of `y` in bytes: {}", std::mem::size_of_val(&y));

println!("size of `z` in bytes: {}", std::mem::size_of_val(&z));

println!("size of `i` in bytes: {}", std::mem::size_of_val(&i));