Rust learning:from germ to grave

Rust官方推荐的三个资料,分别是The Rust programming language,Rust by examples以及ruslings,已经相当充足了.包括相对全面的书,代码例子以及方便的互动式exercises.个人觉得,the book相当于字典,虽然其实还有内容更多的reference,而examples更加易懂上手,rustlings相当于刷题,把关键东西了解一遍.

所以从这三个东西入手开始Rust学习之旅,一些地方会跟c++对比.

宏macro

变量binding

知识点:

  1. 不变性 Rust默认不可变,不像c++到处声明const
  2. scope和shadowing 主要有variable shadowing,也就是可以重声明,在c++中不允许
  3. 将一个mut的值赋值给non-mut的值,在那个域内,non-mute的值也不能被改变
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
27
fn main() {
let mut x = 3;
println!("Number {}", x);
x = 5;
println!("Number {}", x);
}

fn main() {
let number = "T-H-R-E-E"; // don't change this line
println!("Spell a Number : {}", number);
let number = 3; // don't rename this variable
println!("Number plus two is : {}", number + 2);
}
fn main() {
let mut _mutable_integer = 7i32;

{
// Shadowing by immutable `_mutable_integer`
let mut _mutable_integer = _mutable_integer;

_mutable_integer = 50;

// `_mutable_integer` goes out of scope
}

// Ok! `_mutable_integer` is not frozen in this scope
_mutable_integer = 3;

Primitives

字面量和操作符

  1. 推荐在使用字面量是后面加上类型.
  2. 原生类型本身可以printable

元组、数组与slices.

元组,通过()表示,通过.num索引,可以使用#[derive(Debug)]实现方法打印.

数组 [T;length]声明,编译时已知.

切片(Slices)与数组类似,但它们的长度在编译时是未知的。相反,切片是一个由两个字(word)组成的对象:第一个字是指向数据的指针,第二个字是切片的长度。字的大小与 usize 类型相同,由处理器架构决定,例如在 x86-64 上为 64 位。切片可用于借用数组的一部分,它的类型签名为 &[T]

1
2
3
4
5
6
7
8
9
10
11
// This function borrows a slice.
fn analyze_slice(slice: &[i32]) {
println!("First element of the slice: {}", slice[0]);
println!("The slice has {} elements", slice.len());
}

let xs: [i32; 5] = [1, 2, 3, 4, 5];
// All elements can be initialized to the same value.
let ys: [i32; 500] = [0; 500];
println!("Borrow the whole array as a slice.");
analyze_slice(&xs);

自定义类型

structures

使用 struct 关键字可以创建三种类型的结构体(struct):

  1. 元组结构体(Tuple structs),基本上是命名元组。
  2. 经典的 C 风格结构体。
  3. 无字段的单元结构体(Unit structs),在泛型编程中很有用。
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
#[derive(Debug)]
struct Person {
name: String,
age: u8,
}
// A unit struct
struct Unit;

// A tuple struct
struct Pair(i32, f32);

// A struct with two fields
struct Point {
x: f32,
y: f32,
}
// A tuple struct
struct Pair(i32, f32);
// Instantiate a tuple struct
let pair = Pair(1, 0.1);

// Access the fields of a tuple struct
println!("pair contains {:?} and {:?}", pair.0, pair.1);

// Destructure a tuple struct
let Pair(integer, decimal) = pair;

Enums

enum关键字允许创建一个可以是几种不同变体(variant)之一的类型。任何在结构体(struct)中有效的变体,在枚举(enum)中也是有效的。

constants

Rust 有两种不同类型的常量,可以在任何作用域(包括全局)中声明。两种常量都需要显式的类型注解:

  1. const: 不可变的值(最常见的情况)。
  2. static: 可能是可变的变量,拥有 'static 生命周期。'static 生命周期是被推断出来的,不需要显式指定。访问或修改可变的 static 变量是不安全的

后记

作为偏底层的编程语言,c/c++,rust,zig等目前都还在发展,即使c++已过五十年,但C++2a中Concepts,Modules,Coroutines等新特性都不断出现,所以还是地位仍在的.而后两者在前端工具构建上均大显身手,期待后续发展.

我也很喜欢使用C/C++,Go,Rust等写一些小程序demo.

FYI

一些语言高级特性

  1. 谈元编程与表达能力 - 面向信仰编程 (draveness.me)
  2. 从泛型 (Generics) 到元编程 (Metaprogramming) (tsinghua.edu.cn)

image-20240629202803323

image-20240629202943879

-------------本文结束感谢您的阅读-------------
感谢阅读.

欢迎关注我的其它发布渠道