憨憨在减肥的博客

流水要争先，争的是滔滔不绝。

0%

Rust变量与数据类型

发表于 更新于 分类于
本文字数： 4.7k 阅读时长 ≈ 4 分钟

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 中的浮点型可被分为 f32 和 f64。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