Учебники

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

Январь 16, 2019

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

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 и т. Д.

Печать! макрос принимает два аргумента —

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

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

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

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

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

Скалярный тип представляет одно значение. Например, 10,3.14, «с». Ржавчина имеет четыре основных скалярных типа.

  • целое число
  • Плавающая запятая
  • Булевы
  • Персонажи

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

целое число

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

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

Sr.No. Размер подписанный неподписанный
1 8 бит i8 u8
2 16 бит i16 u16
3 32 бит i32 u32
4 64 бит i64 u64
5 128 бит i128 u128
6 арочный ISize usize

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

иллюстрация 

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). При выполнении приведенный выше код вернет предупреждение — предупреждение — литерал вне диапазона для u8 для переменных веса, роста и оценки. Значения переполнения после 255 начнутся с 0, 1, 2 и т. Д. Окончательный результат без предупреждения, как показано ниже — 

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

терка

Тип данных с плавающей точкой в ​​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. Рассмотрим следующий фрагмент кода. Целочисленное значение присваивается переменной с плавающей запятой. 

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

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

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

логический

Булевы типы имеют два возможных значения — true или false . Используйте ключевое слово 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. Скалярные значения Юникода варьируются от 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);
}

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

53
Share: