Rust 语言基础语法:Rust 数据类型简介 1 个改进

类型系统表示语言支持的不同类型的值。 类型系统在提供的值被程序存储或操纵之前检查其有效性。 这样可以确保代码的行为符合预期。 类型系统还允许更丰富的代码提示和自动化文档。

Rust是一种静态类型的语言。 Rust中的每个值都是某种数据类型。 编译器可以根据分配给它的值自动推断变量的数据类型。

声明变量

使用关键词let声明变量。

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

   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);
}

在上面的代码示例中,变量的数据类型是从被分配的值而推断出来的。例如,变量 company_string 被 Rust 分配了 string 字符串数据类型,变量 rating_float 被分配了 float 浮点数据类型,等等。

println! 宏函数有两个参数

  • 一个参数是占位符 { },特别的语法
  • 一个参数是变量或者常量

占位符将被变量的值替换掉

上述代码片段将输出以下内容

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

标量类型(Scalar Types)

一个标量类型代表单个值。 例如10,3.14及字符’c’, Rust 中主要有4种标量类型。

  • 整型
  • 浮点型
  • 布尔型
  • 字符型

我们将在后续部分继续了解各种标量类型。

整型

整型是指没有小数部分的数字。也就是说,整型是用于表示整数的。

整型可以进一步分为有符号(Signed)与无符号(Unsigned)的。有符号的整型既可以存储负数也可以存储正数。无符号的整型只可以存储正数。下面的表格将给出整型的详细说明:

序号 大小 有符号(Signed) 无符号(Unsigned)
1 8 bit i8 u8
2 16 bit i16 u16
3 32 bit i32 u32
4 64 bit i64 u64
5 128 bit i128 u128
6 arch isize usize

整型的大小可以是 arch 。这意味该整型的大小将同机器的位数一致。在32位计算机上,其大小为 arch 的整型将是32位,在64位计算机上则是64位。索引集合时,主要使用大小为 arch 的整型数。

示例

fn main() {
   let result = 10;    // 默认类型为i32
   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^72^7 -1 —— 这里我们把 n 替换为 8。

每个无符号整型值的范围为 0 到 2^n-1。例如,u8 存储值的范围为 0 到 2^8-1,即是 0 到 255。

整型溢出

当分配给整型变量的值超出该整型在 Rust 中定义值的范围时,就会发生整型溢出。让我们用一个例子来帮助理解:

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

   // u8数据范围为0~255
   let weight:u8 = 256;   //溢出值为 1
   let height:u8 = 257;   //溢出值为 2
   let score:u8 = 258;    //溢出值为 3

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

无符号 u8 变量的有效值范围为 0 到 255。在上述例子中,赋给变量的值大于 255(Rust中 u8 整型变量的上限)。编译时上述代码中的 weight,height 和 score 变量将输出错误——error: literal out of range for `u8`。(注:只有编译时标注--release才会编译通过有以下运行结果,否则编译时就会报错)

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

浮点型

Rust 中的浮点型可被分为 f32f64。f32 是单精度浮点型,f64 是双精度浮点型。默认浮点型为 f64。分析以下例子有利于进一步理解浮点型。

fn main() {
   let result = 10.00;        //默认为 f64 浮点型
   let interest:f32 = 8.35;
   let cost:f64 = 15000.600;  //双精度浮点型

   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);
}

编译器将返回如下的不匹配数据类型错误

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 中的字符型用 Unicode 标量值储存,即 Rust 中的字符型可以表示比 ASCII 更多的字符。Unicode 标量值的范围包括从 U+0000U+D7FF 和从 U+E000U+10FFFF

让我们分析以下例子,以更深入地了解字符型。

fn main() {
   let special_character = '@'; //默认为字符型
   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 😁
本文为 Wiki 文章,邀您参与纠错、纰漏和优化
讨论数量: 1

溢出值那个会显示:

rust rustc projects/hello.rs  
error: literal out of range for `u8`
 --> projects/hello.rs:5:21
  |
5 |     let weight:u8 = 256;   //溢出值为 1
  |                     ^^^
  |
  = note: `#[deny(overflowing_literals)]` on by default

error: literal out of range for `u8`
 --> projects/hello.rs:6:21
  |
6 |     let height:u8 = 257;   //溢出值为 2
  |                     ^^^

error: literal out of range for `u8`
 --> projects/hello.rs:7:20
  |
7 |     let score:u8 = 258;    //溢出值为 3
  |                    ^^^

error: aborting due to 3 previous errors

源代码:

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

    // u8数据范围为0~255
    let weight:u8 = 256;   //溢出值为 1
    let height:u8 = 257;   //溢出值为 2
    let score:u8 = 258;    //溢出值为 3

    println!("age is {} ",age);
    println!("weight is {}",weight);
    println!("height is {}",height);
    println!("score is {}",score);
 }
4个月前 评论
Triangle 4个月前
Steven_chen (作者) 4个月前

讨论应以学习和精进为目的。请勿发布不友善或者负能量的内容,与人为善,比聪明更重要!