Rust - Типы данных

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

Rust - это язык со статической типизацией. Каждое значение в Rust относится к определенному типу данных. Компилятор может автоматически определить тип данных переменной на основе присвоенного ей значения.

Объявить переменную

Использовать let ключевое слово для объявления переменной.

fn main() {
   let company_string = "TutorialsPoint";  // string type
   let rating_float = 4.5;                 // float type
   let is_growing_boolean = true;          // boolean type
   let icon_char = '♥';                    //unicode character type

   println!("company name is:{}",company_string);
   println!("company rating on 5 is:{}",rating_float);
   println!("company is growing :{}",is_growing_boolean);
   println!("company icon is:{}",icon_char);
}

В приведенном выше примере тип данных переменных будет выведен из присвоенных им значений. Например, Rust назначит строковый тип данных переменной company_string , тип данных float для rating_float и т. Д.

Println! макрос принимает два аргумента -

• Специальный синтаксис {} , который является заполнителем
• Имя переменной или константа

Заполнитель будет заменен значением переменной

Результатом приведенного выше фрагмента кода будет -

company name is: TutorialsPoint
company rating on 5 is:4.5
company is growing: true
company icon is: ♥

Скалярные типы

Скалярный тип представляет собой одно значение. Например, 10,3,14, 'c'. В Rust есть четыре основных скалярных типа.

• Integer
• Floating-point
• Booleans
• Characters

Мы узнаем о каждом типе в наших следующих разделах.

Целое число

Целое число - это число без дробной части. Проще говоря, целочисленный тип данных используется для представления целых чисел.

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

Sr.No.	Размер	Подписано	Неподписанный
1	8 бит	i8	u8
2	16 бит	i16	u16
3	32 бит	i32	u32
4	64 бит	i64	u64
5	128 бит	i128	u128
6	Арка	Isize	использовать

Размер целого числа может быть арочным . Это означает, что размер типа данных будет зависеть от архитектуры машины. Целое число, размер которого является аркой, будет иметь 32 бита на машине x86 и 64 бита на машине x64. Целое число Arch в основном используется при индексировании какой-либо коллекции.

Иллюстрация

fn main() {
   let result = 10;    // i32 by default
   let age:u32 = 20;
   let sum:i32 = 5-15;
   let mark:isize = 10;
   let count:usize = 30;
   println!("result value is {}",result);
   println!("sum is {} and age is {}",sum,age);
   println!("mark is {} and count is {}",mark,count);
}

Результат будет таким, как указано ниже -

result value is 10
sum is -10 and age is 20
mark is 10 and count is 30

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

Целочисленный диапазон

Каждый вариант со знаком может хранить числа от - (2 ^ (n-1) до 2 ^ (n-1) -1 , где n - количество битов, используемых вариантом. Например, i8 может хранить числа от - (2 ^ 7) до 2 ^ 7-1 - здесь мы заменили n на 8.

Каждый вариант без знака может хранить числа от 0 до (2 ^ n) -1 . Например, u8 может хранить числа от 0 до 2 ^ 7 , что равно от 0 до 255.

Целочисленное переполнение

Целочисленное переполнение происходит, когда значение, присвоенное целочисленной переменной, превышает диапазон, определенный Rust для данного типа данных. Давайте разберемся в этом на примере -

fn main() {
   let age:u8 = 255;

   // 0 to 255 only allowed for u8
   let weight:u8 = 256;   //overflow value is 0
   let height:u8 = 257;   //overflow value is 1
   let score:u8 = 258;    //overflow value is 2

   println!("age is {} ",age);
   println!("weight is {}",weight);
   println!("height is {}",height);
   println!("score is {}",score);
}

Допустимый диапазон беззнаковой переменной u8 - от 0 до 255. В приведенном выше примере переменным присваиваются значения больше 255 (верхний предел для целочисленной переменной в Rust). При выполнении приведенный выше код вернет предупреждение -warning − literal out of range for u8для переменных веса, роста и оценки. Значения переполнения после 255 начнутся с 0, 1, 2 и т. Д. Окончательный вывод без предупреждения показан ниже -

age is 255
weight is 0
height is 1
score is 2

Плавать

Тип данных Float в Rust можно классифицировать как f32 и f64. Тип f32 - это число с плавающей точкой одинарной точности, а f64 - двойной точности. Тип по умолчанию - f64. Рассмотрим следующий пример, чтобы понять больше о типе данных с плавающей запятой.

fn main() {
   let result = 10.00;        //f64 by default
   let interest:f32 = 8.35;
   let cost:f64 = 15000.600;  //double precision
   
   println!("result value is {}",result);
   println!("interest is {}",interest);
   println!("cost is {}",cost);
}

Результат будет таким, как показано ниже -

interest is 8.35
cost is 15000.6

Автоматическое литье типов

Автоматическое приведение типов в Rust запрещено. Рассмотрим следующий фрагмент кода. Переменной с плавающей запятой присваивается целочисленное значение.interest.

fn main() {
   let interest:f32 = 8;   // integer assigned to float variable
   println!("interest is {}",interest);
}

Компилятор выдает mismatched types error как указано ниже.

error[E0308]: mismatched types
   --> main.rs:2:22
   |
 2 | let interest:f32=8;
   |    ^ expected f32, found integral variable
   |
   = note: expected type `f32`
      found type `{integer}`
error: aborting due to previous error(s)

Разделитель чисел

Для удобства чтения больших чисел мы можем использовать визуальный разделитель _ подчеркивание для разделения цифр. То есть 50 000 можно записать как 50_000. Это показано в примере ниже.

fn main() {
   let float_with_separator = 11_000.555_001;
   println!("float value {}",float_with_separator);
   
   let int_with_separator = 50_000;
   println!("int value {}",int_with_separator);
}

Результат приведен ниже -

float value 11000.555001
int value 50000

Булево

У логических типов есть два возможных значения - истина или ложь . Использоватьbool ключевое слово для объявления логической переменной.

Иллюстрация

fn main() {
   let isfun:bool = true;
   println!("Is Rust Programming Fun ? {}",isfun);
}

Вывод приведенного выше кода будет -

Is Rust Programming Fun ? true

символ

Символьный тип данных в Rust поддерживает числа, алфавиты, Unicode и специальные символы. Использоватьcharключевое слово для объявления переменной символьного типа данных. Тип char в Rust представляет собой скалярное значение Unicode, что означает, что он может представлять гораздо больше, чем просто ASCII. Скалярные значения Unicode варьируются отU+0000 к U+D7FF и U+E000 к U+10FFFF включительно.

Давайте рассмотрим пример, чтобы лучше понять тип данных Character.

fn main() {
   let special_character = '@'; //default
   let alphabet:char = 'A';
   let emoji:char = '';
   
   println!("special character is {}",special_character);
   println!("alphabet is {}",alphabet);
   println!("emoji is {}",emoji);
}

Вывод приведенного выше кода будет -

special character is @
alphabet is A
emoji is