Rust入门篇 &mut

Hello World

使用 cargo new projectName --bin 创建一个工程
cargo build 和 cargo run命令
cargo配置文件: 工程下的 Cargo.toml 文件

所有权

变量绑定

变量绑定有它们所绑定的的值的所有权。这意味着当一个绑定离开作用域，它们绑定的资源就会被释放。

let a = vec![21]; // let声明一个变量绑定，非变量
a.push(90); // error: cannot borrow immutable local variable `a` as mutable 对象默认是immutable
let a = 'x'; // a 重新绑定一个对象
a = 'a'; // error: re-assignment of immutable variable `a`

拓展：Rust是一门静态隐式类型的语言。

类型在编译时推导，类似也c++11的auto特性

移动语义

Rust确保了对于任何给定的资源都只有一个绑定与之对应。

let a = vec![1, 2];
let b = a; // 将a绑定的对象所有权交给b.
println!("{}", a[0]); // error: use of moved value: `a`

拷贝语义

同其他C-style语言一样， Rust的基本类型具有copy语义

let a = 32;
let b = a;
println!("{}", a); // 不报错

借用(Borrowing)

引子：

fn main() {
fn fn1(arg: Vec<i32>) -> u32 { // 函数的定义格式...
21 // 表达式可以返回一个值
}
let a = vec![21, 32];
fn1(a); // 将a绑定的对象所有权传入函数中...
println!("{}", a[0]); // use of moved value: `a`
}

如何解决这个问题？

1. 使用 borrowing

fn main() {
fn fn1(arg: &Vec<i32>) -> u32 { // 需传入一个引用
21
}
let a = vec![21, 32];
fn1(&a); // 传入&T类型，一个引用类型
println!("{}", a[0]);
}

上述的借用都是immutable借用类型，还有&mut类型。
Rust的借用有一些必须遵守的规则:
在同一作用域中

一个或者多个对资源的引用 &T
只有一个mutable引用 &mut

原因: 在编译时避免数据竞争...

例子：

let mut x = 5;
let y = &mut x;
*y += 1;
println!("{}", x); // cannot borrow `x` as immutable because it is also borrowed as mutable

不过，解决这个问题的方法是... 缩小y的作用范围：

let mut x = 5;
{
let y = &mut x;
*y += 1;
}
println!("{}", x);

2. 对象克隆

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中，引用必须与它引用的资源存活得一样长！

　　如下两例子:

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中 生命周期 这概念是与引用/借用紧密关联的
它定义了引用有效的作用域。

前面见过的有一个引用类型作为参数的函数，之所以没有看到声明周期这东东。是因为声明周期省略造成的错觉。

我们可以以 implicit 或者 explicit 的方式来定义一个函数：

// implicit
fn foo(x: &i32) -> &i32{
}
// explicit
fn bar<'a>(x: &'a i32) -> &'a i32{
}

此外，结构体(struct)也拥有生命周期。
接下来解决struct后再继续...

类型

结构体

一个简单的struct：

struct Point {
x: i32, // Note: 逗号作为分隔符
y: i32,
}
fn main() {
let origin = Point { x: 0, y: 0 };
println!("The origin is at ({}, {})", origin.x, origin.y);
}

应当注意的地方：

struct不支持字段可变性。因此不能在字段上添加 mut修饰
可变性是绑定的一个属性，让变量在一段时间内可变

为啥这样设计，举个例子：

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
}

生命周期 · 续

当结构体中具有引用类型的属性时，结构体就需要使用显示的生命周期。
错误示例：

struct Foo {
x: &i32, // error: missing lifetime specifier
}

正确的写法：

struct Foo<'a> {
x: &'a i32,
}
fn main() {
let y = &5; // 等价于 `let _y = 5; let y = &_y;`
let f = Foo { x: y };
println!("{}", f.x);
}

为什么Foo需要一个生命周期？因为我们需要确保Foo中的任何引用不能比它包含的 i32 的引用活的更久。

impl块

使用impl在Foo中定义一个方法：

fn main() {
let y = &5;
let f = Foo { x: y };
println!("{}", f.x());
}
struct Foo<'a> {
x: &'a i32,
}
impl<'a> Foo<'a> { // 标点符号吓死人系列...
fn x(&self) -> &'a i32 { self.x }
}

'a 就是用来赋予作用域一个名字。
下面介绍一个特殊的命名作用域：

'static
- 在Rust中最常见的： let x: &'static str = "Hello, world.";
1. static FOO: i32 = 10; // 定义一个常量
2. let x: &'static i32 = &FOO;
3. println!("{}", *x);

方法语法

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());
}

方法的第一个参数比较特殊。它有3种变体： `self`， `&self` 和 `&mut self`。 通常使用后两种！ 当方法只是读取struct中的数据时使用`&self`。 若要修改数据则使用`&mut self`。

关联函数

不带self参数的方法就是关联函数。这是一个Rust代码中非常常见的模式。
1. impl Circle {
2. fn new(x: f64, y: f64, radius: f64) -> Circle {
3. Circle {
4. x: x,
5. y: y,
6. radius: radius,
7. }
8. }
- 关联函数的调用： `let c = Circle::new(0.0, 0.0, 2.0);
创建者模式 Builder Pattern
- 见 Builder Pattern

枚举

跟C不同，Rust的枚举可携带数据.... 看个例子

enum Message {
Quit,
ChangeColor(i32, i32, i32),
Move {x: i32, y: i32},
Write(String),
}
// 使用 match 来实现类型的转换
fn process_message(msg: Message) -> i32{
match msg { // match所有分支返回类型必须一致
Message::Quit => 32, // 逗号隔开
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编译器检查穷尽性，要求对每一个枚举的变量都有一个匹配分支。如果你忽略了一个，除非你用_否则它会给你一个编译时错误。

模式

在匹配语句中使用到：

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")
}

解构：对于复合数据类型，可以在模式中进行解析

struct Point {
x: i32,
y: i32,
}
let origin = Point { x: -9, y: 0=77 };
match origin {
Point { x, y } => println!("({},{})", x, y),
}
// 解析部分值使用 .. 来忽略部分或所有值
match origin {
Point { x, .. } => println!("x is {}", x),
}

忽略绑定

fn fn1() -> (i32, i32) {
(33, 43)
}
let (i, _ ) = fn1(); // 只绑定fn1第一个值，忽略第二个值的绑定
println!("{}", i);

模式在Rust中非常强大，以上只介绍了它的几种用法。

Vector

类型 Vec<T>， vector总是在堆上分配数据！ 可以使用vec!宏来创建。

let v = vec![1, 2, 3, 4, 5]; // v: Vec<i32>

let v = vec![0; 10]; // ten zeroes

越界访问

let v = vec![32, 43];
println!("{:?}", v[3]); // 运行时 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>
// 数组长度
println!("{:?}", v.len());

字符串

Rust有两种主要的字符串类型：&str和String。

同 C-style 系， let greeting = "Hello there."; // greeting: &'static str &str编译后存储在程序中，在运行期间一直存在。

String则不同，是一个在堆上分配的字符串。这个字符串可以增长，并且也保证是UTF-8编码的。

let mut s = "Hello".to_string(); // mut s: String
println!("{}", s);
s.push_str(", world.");
println!("{}", s);

String可以通过一个&强制转换为&str：

let tmp = "鬼".to_string();
let s = "什么".to_string() + &tmp; // String + str => String
println!("{:?}", s);

题外话：被恶心到了... str + str 和 String + String 是不被允许的
不懂为啥这样设计

Note : 由于let s = "hello";中"hello"是一个UTF-8编码的字符串，故不能直接用索引来访问字符串的元素。编码扫盲篇

关于Rust的字符串(如"hello")，就好像你在ipython中输入：

注意这里使用的是 python2.7

> a = '严'
> a
> '\xe4\xb8\xa5'
> len(a)
> 3

在python中你可以使用a[2]来访问a指向的str。但这在Rust中是不允许的

大火系列： Rust入门篇 mut相关推荐

Rust入门篇 mut
Rust入门篇 (1) Rust入门篇声明: 本文是在参考 The Rust Programming Language 和 Rust官方教程中文版写的. 个人学习用再PS. 目录这东东果然是必 ...
【IPFS + 区块链系列】入门篇 - IPFS + Ethereum （下篇）-ipfs + Ethereum 大图片存储
目录 1. 系列文章 2. 项目描述及效果展示 3. 阅读本文需要掌握的知识 4. 源码 5. 运行程序 6. 技术交流 1. 系列文章 [IPFS + 区块链系列] 入门篇 - IPFS环境配置 ...
IPFS + 区块链系列】入门篇 - IPFS + Ethereum （中篇）-js-ipfs-api - 图片上传到IPFS以及下载
目录 1. 项目效果图 2. 创建React项目 3. 完成UI逻辑 4. 安装ipfs-api 5. App.js导入IPFS 6. 实现上传图片到IPFS的Promise函数 7. 上传图片到IP ...
IPFS + 区块链系列】入门篇 - IPFS + Ethereum （上篇）-js-ipfs-api
目录 1. 内容简介 2. IPFS-HTTP效果图 3. 实现步骤 3.1 安装create-react-app 3.2 React项目创建 3.3 运行React项目 3.4 浏览项目 3.5 安 ...
Python系列之入门篇——HDFS
Python系列之入门篇--HDFS 简介 HDFS (Hadoop Distributed File System) Hadoop分布式文件系统,具有高容错性,适合部署在廉价的机器上.Python ...
c# hdf5 写string_Pandas系列之入门篇——HDF5
Python系列之入门篇--HDF5 简介 HDF5(层次性数据格式)作用于大数据存储,其高效的压缩方式节约了不少硬盘空间,同时也给查询效率带来了一定的影响,压缩效率越高,查询效率越低.pandas ...
Yocto系列讲解[入门篇] 1 - 快速入门熟悉Yocto的构建
By: fulinux E-mail: fulinux@sina.com Blog: https://blog.csdn.net/fulinus 喜欢的盆友欢迎点赞和订阅! 你的喜欢就是我写作的动力! ...
C# 串口操作系列(1) -- 入门篇，一个标准的，简陋的串口例子。
我假设读者已经了解了c#的语法,本文是针对刚打算解除串口编程的朋友阅读的,作为串口编程的入门范例,也是我这个系列的基础. 我们的开发环境假定为vs2005(虽然我在用vs2010,但避免有些网友用20 ...
软件测试系列之入门篇（一）
一.你知道软件测试有多重要吗? 在国际上,软件测试(软件质量控制)是一件非常重要的工程工作,测试也作为一个非常独立的职业.在IBM.Microsoft等开发大型系统软件公司,很多重要项目的开发测试人员 ...

大火系列： Rust入门篇 mut