数据类型

类型系统表示该语言支持的不同类型的值。 在程序存储或操作所提供的值之前，类型系统会检查它们的有效性。 这确保了代码的行为符合预期。 类型系统还允许更丰富的代码提示和自动化文档。

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 会将 string 数据类型分配给变量 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 有四种主要标量类型。

• 整数
• 浮点
• 布尔值
• 字符

我们将在后续部分中了解每种类型。

整数

整数是没有小数部分的数字。 简单来说，整数数据类型用于表示整数。

整数可以进一步分为有符号整数和无符号整数。 有符号整数可以存储负值和正值。 无符号整数只能存储正值。 下面给出整数类型的详细说明 −

整数的大小可以是arch。 这意味着数据类型的大小将从机器的体系结构中得出。 大小为 arch 的整数在 x86 计算机上为 32 位，在 x64 计算机上为 64 位。 拱形整数主要在对某种集合进行索引时使用。

示例

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&minus的数字；这里我们将n替换为8。

每个无符号变体可以存储从0到(2^n)-1的数字。 例如，u8可以存储从0到(2^8)-1的数字，等于0到255。

整数溢出

当分配给整型变量的值超出 Rust 为数据类型定义的范围时，就会发生整数溢出。 让我们通过一个例子来理解这一点 −

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

   // 0 到 255 仅适用于 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 for weight, height and score variables。

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 中不允许自动类型转换。 考虑以下代码片段。 整数值被分配给浮点变量interest。

fn main() {
   let interest:f32 = 8;   // 赋给浮点变量的整数
   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

布尔值

布尔类型有两个可能的值 - true 或 false。 使用 bool 关键字声明布尔变量。

示例

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

上面的代码的输出结果是 −

Is Rust Programming Fun ? true

字符

Rust 中的字符数据类型支持数字、字母、Unicode 和特殊字符。 使用 char 关键字声明字符数据类型的变量。 Rust 的 char 类型表示 Unicode 标量值，这意味着它可以表示的不仅仅是 ASCII。Unicode 标量值范围从 U+0000 到 U+D7FF 和 U+E000 到 U+10FFFF（含）。

让我们考虑一个示例来了解有关字符数据类型的更多信息。

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 ????