title: "Rust入門篇"
date: 2021-02-04T14:08:39+08:00
draft: true
tags: ['rust']
author: "dadigang"
author_cn: "大地缸"
personal: "http://www.real007.cn"
關(guān)于作者
Rust入門篇 (1)
開(kāi)始入坑...
Rust入門篇
聲明： 本文是在參考 The Rust Programming Language 和 Rust官方教程 中文版 寫的。 個(gè)人學(xué)習(xí)用
再PS. 目錄這東東果然是必須的... 找個(gè)時(shí)間生成個(gè)
Hello World
- 使用
cargo new projectName --bin創(chuàng)建一個(gè)工程 -
cargo build和cargo run命令 - cargo配置文件: 工程下的 Cargo.toml 文件
所有權(quán)
變量綁定
變量綁定有它們所綁定的的值的所有權(quán)。這意味著當(dāng)一個(gè)綁定離開(kāi)作用域，它們綁定的資源就會(huì)被釋放。
let a = vec![21]; // let聲明一個(gè)變量綁定，非變量
a.push(90); // error: cannot borrow immutable local variable `a` as mutable 對(duì)象默認(rèn)是immutable
let a = 'x'; // a 重新綁定一個(gè)對(duì)象
a = 'a'; // error: re-assignment of immutable variable `a`
- 拓展：Rust是一門靜態(tài)隱式類型的語(yǔ)言。
> 類型在編譯時(shí)推導(dǎo)， 類似也c++11的`auto`特性
移動(dòng)語(yǔ)義
Rust確保了對(duì)于任何給定的資源都只有一個(gè)綁定與之對(duì)應(yīng)。
let a = vec![1, 2];
let b = a; // 將a綁定的對(duì)象所有權(quán)交給b.
println!("{}", a[0]); // error: use of moved value: `a`
拷貝語(yǔ)義
同其他C-style語(yǔ)言一樣， Rust的基本類型具有copy語(yǔ)義
let a = 32;
let b = a;
println!("{}", a); // 不報(bào)錯(cuò)
借用(Borrowing)
- 引子：
fn main() {
fn fn1(arg: Vec<i32>) -> u32 { // 函數(shù)的定義格式...
21 // 表達(dá)式可以返回一個(gè)值
}
let a = vec![21, 32];
fn1(a); // 將a綁定的對(duì)象所有權(quán)傳入函數(shù)中...
println!("{}", a[0]); // use of moved value: `a`
}
如何解決這個(gè)問(wèn)題？
1. 使用 borrowing
fn main() {
fn fn1(arg: &Vec<i32>) -> u32 { // 需傳入一個(gè)引用
21
}
let a = vec![21, 32];
fn1(&a); // 傳入&T類型，一個(gè)引用類型
println!("{}", a[0]);
}
上述的借用都是immutable借用類型， 還有&mut類型。
Rust的借用有一些必須遵守的規(guī)則:
在同一作用域中
- 一個(gè)或者多個(gè)對(duì)資源的引用
&T - 只有一個(gè)mutable引用
&mut
原因: 在編譯時(shí)避免數(shù)據(jù)競(jìng)爭(zhēng)...
- 例子：
let mut x = 5;
let y = &mut x;
*y += 1;
println!("{}", x); // cannot borrow `x` as immutable because it is also borrowed as mutable
不過(guò)，解決這個(gè)問(wèn)題的方法是... 縮小y的作用范圍：
let mut x = 5;
{
let y = &mut x;
*y += 1;
}
println!("{}", x);
2. 對(duì)象克隆
fn main() {
fn fn1(arg: Vec<i32>) -> u32 {
21
}
let a = vec![21, 32];
fn1(a.clone()); // 將a的副本傳入即可
println!("{}", a[0]); // use of moved value: `a`
}
生命周期
在Rust中，引用必須與它引用的資源存活得一樣長(zhǎng)！
如下兩例子:
let r : &i32;
{
let a = 32;
r = &32; // error: borrowed value does not live long enough
}
println!("{}", r);
let r : &i32;
let x = 78;
r = &x; // error: `x` does not live long enough
- 注意在Rust中 生命周期 這概念是與引用/借用緊密關(guān)聯(lián)的
- 它定義了引用有效的作用域。
前面見(jiàn)過(guò)的有一個(gè)引用類型作為參數(shù)的函數(shù)，之所以沒(méi)有看到聲明周期這東東。 是因?yàn)?聲明周期省略 造成的錯(cuò)覺(jué)。
我們可以以 implicit 或者 explicit 的方式來(lái)定義一個(gè)函數(shù)：
// implicit
fn foo(x: &i32) -> &i32{
}
// explicit
fn bar<'a>(x: &'a i32) -> &'a i32{
}
此外，結(jié)構(gòu)體(struct)也擁有生命周期。
接下來(lái)解決struct后再繼續(xù)...
類型
結(jié)構(gòu)體
一個(gè)簡(jiǎn)單的struct：
struct Point {
x: i32, // Note: 逗號(hào)作為分隔符
y: i32,
}
fn main() {
let origin = Point { x: 0, y: 0 };
println!("The origin is at ({}, {})", origin.x, origin.y);
}
應(yīng)當(dāng)注意的地方：
- struct不支持字段可變性。因此不能在字段上添加
mut修飾 - 可變性是綁定的一個(gè)屬性， 讓變量在一段時(shí)間內(nèi)可變
為啥這樣設(shè)計(jì)， 舉個(gè)例子：
struct Point {
x: i32,
y: i32,
}
fn main() {
let mut point = Point { x: 0, y: 0 };
point.x = 5;
let point = point; // this new binding can’t change now
point.y = 6; // this causes an error
}
生命周期 · 續(xù)
當(dāng)結(jié)構(gòu)體中具有引用類型的屬性時(shí)， 結(jié)構(gòu)體就需要使用顯示的生命周期。
錯(cuò)誤示例：
struct Foo {
x: &i32, // error: missing lifetime specifier
}
正確的寫法：
struct Foo<'a> {
x: &'a i32,
}
fn main() {
let y = &5; // 等價(jià)于 `let _y = 5; let y = &_y;`
let f = Foo { x: y };
println!("{}", f.x);
}
為什么Foo需要一個(gè)生命周期？ 因?yàn)槲覀冃枰_保Foo中的任何引用不能比它包含的 i32 的引用活的更久。
impl塊
使用impl在Foo中定義一個(gè)方法：
fn main() {
let y = &5;
let f = Foo { x: y };
println!("{}", f.x());
}
struct Foo<'a> {
x: &'a i32,
}
impl<'a> Foo<'a> { // 標(biāo)點(diǎn)符號(hào)嚇?biāo)廊讼盗?..
fn x(&self) -> &'a i32 { self.x }
}
'a 就是用來(lái)賦予作用域一個(gè)名字。
下面介紹一個(gè)特殊的命名作用域：
'static
- 在Rust中最常見(jiàn)的： `let x: &'static str = "Hello, world.";`
```rust
static FOO: i32 = 10; // 定義一個(gè)常量
let x: &'static i32 = &FOO;
println!("{}", *x);
```
方法語(yǔ)法
struct Circle {
x: f64,
y: f64,
radius: f64,
}
impl Circle {
fn area(&self) -> f64 {
std::f64::consts::PI * (self.radius * self.radius)
}
}
fn main() {
let c = Circle { x: 0.0, y: 0.0, radius: 2.0 };
println!("{}", c.area());
}
方法的第一個(gè)參數(shù)比較特殊。它有3種變體： `self`， `&self` 和 `&mut self`。 通常使用后兩種！ 當(dāng)方法只是讀取struct中的數(shù)據(jù)時(shí)使用`&self`。 若要修改數(shù)據(jù)則使用`&mut self`。
- 關(guān)聯(lián)函數(shù)
> 不帶self參數(shù)的方法就是關(guān)聯(lián)函數(shù)。 這是一個(gè)Rust代碼中非常常見(jiàn)的模式。
```rust
impl Circle {
fn new(x: f64, y: f64, radius: f64) -> Circle {
Circle {
x: x,
y: y,
radius: radius,
}
}
```
- 關(guān)聯(lián)函數(shù)的調(diào)用： \`let c = Circle::new(0.0, 0.0, 2.0);
-
創(chuàng)建者模式 Builder Pattern
- 見(jiàn) Builder Pattern
枚舉
跟C不同，Rust的枚舉可攜帶數(shù)據(jù).... 看個(gè)例子
enum Message {
Quit,
ChangeColor(i32, i32, i32),
Move {x: i32, y: i32},
Write(String),
}
// 使用 match 來(lái)實(shí)現(xiàn)類型的轉(zhuǎn)換
fn process_message(msg: Message) -> i32{
match msg { // match所有分支返回類型必須一致
Message::Quit => 32, // 逗號(hào)隔開(kāi)
Message::ChangeColor(r,g,b) => r+g+b,
Message::Move{x: x1, y: y1} => x1 + y1,
Message::Write(s) => s.trim().parse().ok().expect("parse error!"),
}
}
fn main() {
let a = Message::Quit;
let b = Message::ChangeColor(1, 2, 3);
let c = Message::Move{x: 32, y: -32};
let d = Message::Write("88".to_string());
println!("{}", process_message(a));
println!("{}", process_message(b));
println!("{}", process_message(c));
println!("{}", process_message(d));
}
匹配和模式
let x = 5;
match x {
1 => println!("one"),
2 => println!("two"),
3 => println!("three"),
4 => println!("four"),
5 => println!("five"),
_ => println!("something else"),
}
Rust編譯器檢查窮盡性，要求對(duì)每一個(gè)枚舉的變量都有一個(gè)匹配分支。如果你忽略了一個(gè)，除非你用_否則它會(huì)給你一個(gè)編譯時(shí)錯(cuò)誤。
模式
在匹配語(yǔ)句中使用到：
let my_number = 8;
match my_number {
0 => println!("zero"),
1 | 2 => println!("one or two"), // Multiple patterns
3 ... 10 => println!("three to ten"), // Ranges
_ => println!("something else")
}
解構(gòu)： 對(duì)于復(fù)合數(shù)據(jù)類型， 可以在模式中進(jìn)行解析
struct Point {
x: i32,
y: i32,
}
let origin = Point { x: -9, y: 0=77 };
match origin {
Point { x, y } => println!("({},{})", x, y),
}
// 解析部分值 使用 .. 來(lái)忽略部分或所有值
match origin {
Point { x, .. } => println!("x is {}", x),
}
忽略綁定
fn fn1() -> (i32, i32) {
(33, 43)
}
let (i, _ ) = fn1(); // 只綁定fn1第一個(gè)值， 忽略第二個(gè)值的綁定
println!("{}", i);
模式在Rust中非常強(qiáng)大，以上只介紹了它的幾種用法。
Vector
類型 Vec<T>， vector總是在堆上分配數(shù)據(jù)！ 可以使用vec!宏來(lái)創(chuàng)建。
let v = vec![1, 2, 3, 4, 5]; // v: Vec<i32>
let v = vec![0; 10]; // ten zeroes
越界訪問(wèn)
let v = vec![32, 43];
println!("{:?}", v[3]); // 運(yùn)行時(shí) thread '<main>' panicked at 'index out of bounds
迭代
let mut v = vec![1, 2, 3, 4, 5];
for i in &v {
println!("A reference to {}", i);
}
方法
let v = vec![43, 54, 65]; // v: Vec<i32>
// 數(shù)組長(zhǎng)度
println!("{:?}", v.len());
字符串
Rust有兩種主要的字符串類型：&str和String。
同 C-style 系， let greeting = "Hello there."; // greeting: &'static str &str編譯后存儲(chǔ)在程序中， 在運(yùn)行期間一直存在。
String則不同，是一個(gè)在堆上分配的字符串。這個(gè)字符串可以增長(zhǎng)，并且也保證是 UTF-8編碼 的。
let mut s = "Hello".to_string(); // mut s: String
println!("{}", s);
s.push_str(", world.");
println!("{}", s);
String可以通過(guò)一個(gè)&強(qiáng)制轉(zhuǎn)換為&str：
let tmp = "鬼".to_string();
let s = "什么".to_string() + &tmp; // String + str => String
println!("{:?}", s);
題外話： 被惡心到了... str + str 和 String + String 是不被允許的
不懂為啥這樣設(shè)計(jì)
Note : 由于let s = "hello";中"hello"是一個(gè)UTF-8編碼的字符串，故不能直接用索引來(lái)訪問(wèn)字符串的元素。 編碼掃盲篇
關(guān)于Rust的字符串(如"hello")， 就好像你在ipython中輸入：
注意這里使用的是 python2.7
> a = '嚴(yán)'
> a
> '\xe4\xb8\xa5'
> len(a)
> 3
在python中你可以使用a[2]來(lái)訪問(wèn)a指向的str。 但這在Rust中是不允許的
---恢復(fù)內(nèi)容結(jié)束---
