0%

Rust变量与数据类型

Rust变量与数据类型

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

let

使用let关键字声明变量

1
2
3
4
5
6
7
8
9
10
11
12
13
fn main() {
println!("Rust基础语法!");
let str_ = "String"; // string 类型
let f_ = 1.1; // float 类型
let bool_ = true; // boolean 类型
let char_ = 'a'; // unicode character
println!("string {}",str_);
println!("float {}",f_);
println!("boolean {}",bool_);
println!("icon {}",char_);


}
  • Console
1
2
3
4
5
Rust基础语法!
string String
float 1.1
boolean true
icon a

println!

打印控制台方法

1
2
3
4
5
6
7
8
9
10

#[macro_export]
#[stable(feature = "rust1", since = "1.0.0")]
#[allow_internal_unstable(print_internals, format_args_nl)]
macro_rules! println {
() => ($crate::print!("\n"));
($($arg:tt)*) => ({
$crate::io::_print($crate::format_args_nl!($($arg)*));
})
}
  • 一个参数是占位符 *{ }*,特别的语法
  • 一个参数是变量或者常量

scalar Types

Rust有四种标量类型 整型、浮点型、布尔型、字符型

整型

整型是指没有小数部分的数字。也就是说,整型是用于表示整数的。整型可以进一步分为有符号(Signed)与无符号(Unsigned)的。可以存储正负值。

大小 有符号Signed 无符号Unsigned
8bit i8 u8
16bit i16 u16
32bit i32 u32
64bit i64 u64
128bit i128 u128
arch issize Size
案例
1
2
3
4
5
6
7
8
let result = 1;    // 默认类型为i32
let u20:u32 = 20;
let i32:i32 = -15;
let s:isize = 10;
let count:usize = 30;
println!("result value is {}",result);
println!("u20 is {} i32 is {}",u20,i32);
println!("mark is {} and count is {}",s,count);
  • Console
1
2
3
result value is 1
u20 is 20 i32 is -15
mark is 10 and count is 30

整型溢出

当分配给整型变量的值超出该整型在 Rust 中定义值的范围时,就会发生整型溢出

案例
1
2
3
4
5
6
7
8
9
10
let u1:u8 = 255;
// u8数据范围为0~255
let u2:u8 = 256; //溢出值为 1
let u3:u8 = 257; //溢出值为 2
let u4:u8 = 258; //溢出值为 3

println!("1 is {} ",u1);
println!("2 is {}",u2);
println!("3 is {}",u3);
println!("4 is {}",u4);
  • Console
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
error: literal out of range for `u8`
--> src/main.rs:24:16
|
24 | let u2:u8 = 256; //溢出值为 1
| ^^^
|
= note: `#[deny(overflowing_literals)]` on by default
= note: the literal `256` does not fit into the type `u8` whose range is `0..=255`

error: literal out of range for `u8`
--> src/main.rs:25:16
|
25 | let u3:u8 = 257; //溢出值为 2
| ^^^
|
= note: the literal `257` does not fit into the type `u8` whose range is `0..=255`

error: literal out of range for `u8`
--> src/main.rs:26:16
|
26 | let u4:u8 = 258; //溢出值为 3
| ^^^
|
= note: the literal `258` does not fit into the type `u8` whose range is `0..=255`

error: could not compile `learning-02` due to 3 previous errors
  • Rust的提示非常棒

浮点型

Rust 中的浮点型可被分为 f32f64。f32 是单精度浮点型,f64 是双精度浮点型。默认浮点型为 f64。

案例
1
2
3
4
5
6
7
let f1 = 10.00;        //默认为 f64 浮点型
let f2:f32 = 8.35;
let f3:f64 = 15000.600; //双精度浮点型

println!("f1 value is {}",f1);
println!("f2 is {}",f2);
println!("f3 is {}",f3);
  • Console
1
2
3
f1 value is 10
f2 is 8.35
f3 is 15000.6

自动类型转换

Rust 中不支持自动类型转换

案例
1
2
let interest:f32 = 8;   // 浮点型变量被赋予整型值
println!("interest is {}",interest);
  • Console
1
2
3
4
5
6
7
8
9
error[E0308]: mismatched types
--> src/main.rs:41:23
|
41 | let interest:f32 = 8; // 浮点型变量被赋予整型值
| --- ^
| | |
| | expected `f32`, found integer
| | help: use a float literal: `8.0`
| expected due to this

布尔值

布尔型有两种可能的值 ——true 或是 false。使用 bool 关键字可以声明布尔型变量。

案例
1
2
let b:bool = true;
println!("boolean {}",b);
  • Console
1
boolean true

字符型

Rust 中的字符型支持数字,字母,Unicode 和特殊字符。使用 char 关键字可以声明字符型变量。Rust 中的字符型用 Unicode 标量值储存,即 Rust 中的字符型可以表示比 ASCII 更多的字符。Unicode 标量值的范围包括从 U+0000 到 U+D7FF 和从 U+E000 到 U+10FFFF。

案例
1
2
3
let def_c = '@'; //默认为字符型
let c:char = 'Z';
let emoji:char = '😁';
  • Console
1
2
3
character is @
alphabet is Z
emoji is 😁
类型转字符串

to_String()

案例
1
2
3
let x: u32 = 10;
let s: String = x.to_string();
println!("{}", s);
  • Console
1
10

let变量

变量是程序可以操纵的命名存储

  • 必须以字母或下划线开头。

  • 变量的名称可以由字母,数字和下划线字符组成。

  • Rust区分大小写

  • 不可变性

    • 变量默认是不可变的,只读的。也就是说,变量的值在初始化后不可再被改变。比如
1
2
3
4
let var = 25_000;
println!("var is {} ",var);
var = 35_000;
println!("var changed is {}",var);

Console

1
2
3
4
5
6
7
8
9
10
  --> src/main.rs:57:5
|
55 | let var = 25_000;
| ---
| |
| first assignment to `var`
| help: consider making this binding mutable: `mut var`
56 | println!("var is {} ",var);
57 | var = 35_000;
| ^^^^^^^^^^^^ cannot assign twice to immutable variable
  • 可变性
    • 在变量名前加上 mut 关键字可以使其可变。可变变量的值可以更改。
1
2
3
4
let mut var = 25_000;
println!("var is {} ",var);
var = 35_000;
println!("var changed is {}",var);

Console

1
2
var is 25000 
var changed is 35000

const常量

常量一定要显式声明它的数据类型。以下是声明常量的语法:

  • 而声明常量时一定要声明它的数据类型。const VARIABLE_NAME:dataType = value;
  • 使用 let 关键字声明的变量默认是不可变的。但是你可以选择使用 mut 关键字来使其可变。常量则永远是不可变的
  • 常量可以在任何范围内声明,包括全局范围。
案例
1
2
const VAR_NAME:char = 'A';
println!("VAR_NAME is {}",VAR_NAME);
  • Console
1
VAR_NAME is A

shadowing 覆盖

Rust 支持不同数据类型的变量之间的覆盖(隐藏 shadowing)。

  • 变量可以被覆盖,常量不行。
案例一
1
2
3
4
let salary = 100.00;
let salary = 1.50 ;
// 读取salary变量的值
println!("The value of salary is :{}",salary);
  • Console
1
The value of salary is :1.5
案例二
1
2
3
4
5

const salary2 = 100.00;
let salary2 = 1.50 ;
// 读取salary变量的值
println!("The value of salary is :{}",salary2);
  • Console
1
2
3
4
  --> src/main.rs:68:11
|
68 | const salary2 = 100.00;
| ^^^^^^^ help: provide a type for the constant: `salary2: f64`

操作符

运算符(操作符)定义了对于数据的的处理。被运算符所作用的数据被称为运算数。

算数运算法

  • 加 +
  • 减 -
  • 乘 *
  • 除 /
  • 取余 %

操作运算符

  • > 大于
  • <小于
  • >= 大于等于
  • <= 小于等于
  • == 等于
  • != 不等于

逻辑运算符

  • &&
  • ||
  • !

位运算符

  • & (按位与)
  • |(按位或)
  • ^(按位异或)
  • !(按位非)
  • <<(左移)
  • >>(右移)
  • >>>(无符号右移)

END