Rust学习笔记（3）- 变量和可变属性

2022-04-07 09:36:37 浏览数 (1)

变量和可变属性

变量定义

代码语言：javascript复制
let x = 5;

用let关键字定义变量，rust这一点和python、js很像，是弱数据类型的，通过赋值来推测变量类型。

需要注意的是，这样直接定义的变量，不能再次赋值，比如：

代码语言：javascript复制
let x = 5;
println!("The value of x is: {}", x);
x = 6;
println!("The value of x is: {}", x);

就会直接报错，会提示不能第二次给不可变的变量赋值（cannot assign twice to immutable variable）。 除非写成这样：

代码语言：javascript复制
let mut x = 5;
println!("The value of x is: {}", x);
x = 6;
println!("The value of x is: {}", x);

这样倒是没问题，因为mut关键字指定了x是可变的。Rust里面，默认居然是不可变的，变量还要主动指定mut，才是可变的！WTF！

常量

下面是常量的定义方式：

代码语言：javascript复制
const THREE_HOURS_IN_SECONDS: u32 = 60 * 60 * 3;

关键字const定义常量，常量必须指定数据类型，比如u32，很奇怪的是，前面介绍的let x = 5，同样是赋值一次后不可变，本身也有常量的意思了，这里还提供了const关键字作为常量定义，让我有点感觉多余。虽然根据官方的解释，这两者有区别：

  1. 不能使用mut关键字来指const常量可变；
  2. 可定义的范围（scope）不同，const可以在任何位置定义，甚至是全局环境；
  3. 可以给一个const常量赋值一个常量表达式（如上面的例子）

阴影

这个概念不好理解，其实就是定义和前面同名的变量，那么后面的会覆盖住前面的变量。看个例子就明白了：

代码语言：javascript复制
fn main() {
    let x = 5;

    let x = x   1;

    {
        let x = x * 2;
        println!("The value of x in the inner scope is: {}", x);
    }

    println!("The value of x is: {}", x);
}

执行结果：

代码语言：javascript复制
$ cargo run
   Compiling variables v0.1.0 (file:///projects/variables)
    Finished dev [unoptimized   debuginfo] target(s) in 0.31s
     Running `target/debug/variables`
The value of x in the inner scope is: 12
The value of x is: 6

数据类型

Rust语言规定每一个值都要有明确的数据类型，虽然在变量定义时，是弱数据类型的（不需要在定义变量时说明变量的数据类型），但是变量的数据类型必须可以被推测，如果在赋值时不能被推测，那么就强制要求定义时必须要指定类型。比如下面这个例子：

代码语言：javascript复制
let guess: u32 = "42".parse().expect("Not a number!");

如果没有指定guess为u32类型，就会出现：

代码语言：javascript复制
$ cargo build
   Compiling no_type_annotations v0.1.0 (file:///projects/no_type_annotations)
error[E0282]: type annotations needed
 --> src/main.rs:2:9
  |
2 |     let guess = "42".parse().expect("Not a number!");
  |         ^^^^^ consider giving `guess` a type

For more information about this error, try `rustc --explain E0282`.
error: could not compile `no_type_annotations` due to previous error

显然是parse方法无法进行类型转换的推测，所以报错了。必须要给guess一个明确的类型，parse方法才知道要转成什么类型。

简单标量类型

Rust内置4种标量类型——整型，浮点型，布尔型，字符型。

整型

类型有6种：

Length

Signed

Unsigned

8-bit

i8

u8

16-bit

i16

u16

32-bit

i32

u32

64-bit

i64

u64

128-bit

i128

u128

arch

isize

usize

整型的字面表达（literal）是这样的：

字面类型

例子

十进制

98_222

十六进制

0xff

八进制

0o77

二进制

0b1111_0000

字节 (u8)

b’A’

浮点类型

Rust的两个浮点类型是f32和f64，默认一个浮点数是f64的：

代码语言：javascript复制
fn main() {
    let x = 2.0; // f64

    let y: f32 = 3.0; // f32
}

布尔类型

很简单，就是bool，值就是true和false，在内存中，只占一个字节:

代码语言：javascript复制
fn main() {
    let t = true;

    let f: bool = false; // with explicit type annotation
}

字符类型

和java完全一样，用单引号表示一个unicode字符，在内存中占4个字节：

代码语言：javascript复制
fn main() {
    let c = 'z';
    let z = 'ℤ';
    let heart_eyed_cat = '


	


rust 编程算法 java 




	






	

 0 人点赞