Rust学习第五天

1、Rust Slice（切片）类型

切片（Slice）是对数据值的部分引用。

字符串切片

最简单、最常用的数据切片类型是字符串切片（String Slice）。

fn main() {
    let s = String::from("broadcast");
	let part1 = &s[0..5];
	let part2 = &s[5..9];

	println!("{}={}+{}", s, part1, part2);

}

运行结果：

1	broadcast=broad+cast

上图解释了字符串切片的原理（注：Rust 中的字符串类型实质上记录了字符在内存中的起始位置和其长度，我们暂时了解到这一点）。

使用 .. 表示范围的语法在循环章节中出现过。x..y 表示 [x, y) 的数学含义。.. 两边可以没有运算数：

1
2
3

..y 等价于 0..y
x.. 等价于位置 x 到数据结束
.. 等价于位置 0 到结束

数据切片的原理实际上是类似于指针一样记录初始位置选定切片长度之后对原数据进行切片。

注意：到目前为止，尽量不要在字符串中使用非英文字符，因为编码的问题。具体原因会在”字符串”章节叙述。

被切片引用的字符串禁止更改其值：

fn main() {
    let mut s = String::from("test");
    let slice = &s[0..3];
    s.push_str("yes!"); // 错误
    println!("slice = {}", slice);
}

这段程序不正确。

s 被部分引用，禁止更改其值。

实际上，到目前为止你一定疑惑为什么每一次使用字符串都要这样写String::from(“test”) ，直接写 “test” 不行吗？

事已至此我们必须分辨这两者概念的区别了。

在 Rust 中有两种常用的字符串类型：str 和 String。str 是 Rust 核心语言类型，就是本章一直在讲的字符串切片（String Slice），常常以引用的形式出现（&str）。

凡是用双引号包括的字符串常量整体的类型性质都是 &str：

1	let s = "hello";

这里的 s 就是一个 &str 类型的变量。

String 类型是 Rust 标准公共库提供的一种数据类型，它的功能更完善——它支持字符串的追加、清空等实用的操作。String 和 str 除了同样拥有一个字符开始位置属性和一个字符串长度属性以外还有一个容量（capacity）属性。

String 和 str 都支持切片，切片的结果是 &str 类型的数据。

注意：切片结果必须是引用类型，但开发者必须自己明示这一点:

1	let slice = &s[0..3];

有一个快速的办法可以将 String 转换成 &str：

1 2	let s1 = String::from("hello"); let s2 = &s1[..];

非字符串切片

除了字符串以外，其他一些线性数据结构也支持切片操作，例如数组：

fn main() {
    let arr = [1, 3, 5, 7, 9];
    let part = &arr[0..3];
    for i in part.iter() {
        println!("{}", i);
    }
}

2、Rust结构体

Rust 中的结构体（Struct）与元组（Tuple）都可以将若干个类型不一定相同的数据捆绑在一起形成整体，但结构体的每个成员和其本身都有一个名字，这样访问它成员的时候就不用记住下标了。

元组常用于非定义的多值传递，而结构体用于规范常用的数据结构。结构体的每个成员叫做”字段”。

结构体定义

这是一个结构体定义：

struct Site {
    domain: String,
    name: String,
    nation: String,
    found: u32
}

注意：如果你常用 C/C++，请记住在 Rust 里 struct 语句仅用来定义，不能声明实例，结尾不需要 ; 符号，而且每个字段定义之后用 , 分隔。

结构体实例

Rust 很多地方受 JavaScript 影响，在实例化结构体的时候用 JSON 对象的 key: value 语法来实现定义：

let xuyu = Site {
    domain: String::from("xuyu"),
    name: String::from("ling"),
    nation: String::from("China")
};

如果你不了解 JSON 对象，你可以不用管它，记住格式就可以了：

结构体类名 {
    字段名 : 字段值,
    ...
}

这样的好处是不仅使程序更加直观，还不需要按照定义的顺序来输入成员的值。

如果正在实例化的结构体有字段名称和现存变量名称一样的，可以简化书写：

let domain = String::from("xuyu");
let name = String::from("xu");
let runoob = Site {
    domain,  // 等同于 domain : domain,
    name,    // 等同于 name : name,
    nation: String::from("China")
};

有这样一种情况：你想要新建一个结构体的实例，其中大部分属性需要被设置成与现存的一个结构体属性一样，仅需更改其中的一两个字段的值，可以使用结构体更新语法：

let site = Site {
    domain: String::from("www.runoob.com"),
    name: String::from("RUNOOB"),
    ..runoob
};

注意：..runoob 后面不可以有逗号。这种语法不允许一成不变的复制另一个结构体实例，意思就是说至少重新设定一个字段的值才能引用其他实例的值。

元组结构体

有一种更简单的定义和使用结构体的方式：元组结构体。

元组结构体是一种形式是元组的结构体。

与元组的区别是它有名字和固定的类型格式。它存在的意义是为了处理那些需要定义类型（经常使用）又不想太复杂的简单数据：

struct Color(u8, u8, u8);
struct Point(f64, f64);

let black = Color(0, 0, 0);
let origin = Point(0.0, 0.0);

“颜色”和”点坐标”是常用的两种数据类型，但如果实例化时写个大括号再写上两个名字就为了可读性牺牲了便捷性，Rust 不会遗留这个问题。元组结构体对象的使用方式和元组一样，通过 . 和下标来进行访问：

fn main() {
    struct Color(u8, u8, u8);
    struct Point(f64, f64);
    
	let black = Color(0, 0, 0);
	let origin = Point(0.0, 0.0);

	println!("black = ({}, {}, {})", black.0, black.1, black.2);
	println!("origin = ({}, {})", origin.0, origin.1);

}

结构体所有权

结构体必须掌握字段值所有权，因为结构体失效的时候会释放所有字段。

这就是为什么案例中使用了 String 类型而不使用 &str 的原因。

输出结构体

调试中，完整地显示出一个结构体实例是非常有用的。但如果我们手动的书写一个格式会非常的不方便。所以 Rust 提供了一个方便地输出一整个结构体的方法：

#[derive(Debug)]

struct Rectangle {
    width: u32,
    height: u32,
}

fn main() {
    let rect1 = Rectangle { width: 30, height: 50 };

	println!("rect1 is {:?}", rect1);

}

运行结果：

1	rect1 is Rectangle { width: 30, height: 50 }

如第一行所示：一定要导入调试库 #[derive(Debug)] ，之后在 println 和 print 宏中就可以用 {:?} 占位符输出一整个结构体：

如果属性较多的话可以使用另一个占位符 {:#?} 。

运行结果：

rect1 is Rectangle {
    width: 30,
    height: 50
}

结构体方法

方法（Method）和函数（Function）类似，只不过它是用来操作结构体实例的。

如果你学习过一些面向对象的语言，那你一定很清楚函数一般放在类定义里并在函数中用 this 表示所操作的实例。

Rust 语言不是面向对象的，从它所有权机制的创新可以看出这一点。但是面向对象的珍贵思想可以在 Rust 实现。

结构体方法的第一个参数必须是 &self，不需声明类型，因为 self 不是一种风格而是关键字。

计算一个矩形的面积：

struct Rectangle {
    width: u32,
    height: u32,
}
    
impl Rectangle {
    fn area(&self) -> u32 {
        self.width * self.height
    }
}

fn main() {
    let rect1 = Rectangle { width: 30, height: 50 };
    println!("rect1's area is {}", rect1.area());
}

输出结果：

1	rect1's area is 1500

请注意，在调用结构体方法的时候不需要填写 self ，这是出于对使用方便性的考虑。

一个多参数的例子：

struct Rectangle {
    width: u32,
    height: u32,
}

impl Rectangle {
    fn area(&self) -> u32 {
        self.width * self.height
    }
    
fn wider(&self, rect: &Rectangle) -> bool {
    self.width > rect.width
}

}

fn main() {
    let rect1 = Rectangle { width: 30, height: 50 };
    let rect2 = Rectangle { width: 40, height: 20 };

println!("{}", rect1.wider(&rect2));

}

运行结果：

false

这个程序计算 rect1 是否比 rect2 更宽。

结构体关联函数

之所以”结构体方法”不叫”结构体函数”是因为”函数”这个名字留给了这种函数：它在 impl 块中却没有 &self 参数。

这种函数不依赖实例，但是使用它需要声明是在哪个 impl 块中的。

一直使用的 String::from 函数就是一个”关联函数”。

#[derive(Debug)]
struct Rectangle {
    width: u32,
    height: u32,
}

impl Rectangle {
    fn create(width: u32, height: u32) -> Rectangle {
        Rectangle { width, height }
    }
}

fn main() {
    let rect = Rectangle::create(30, 50);
    println!("{:?}", rect);
}

运行结果：

1	Rectangle { width: 30, height: 50 }

贴士：结构体 impl 块可以写几次，效果相当于它们内容的拼接！

单元结构体

结构体可以只作为一种象征而无需任何成员：

1	struct UnitStruct;

我们称这种没有身体的结构体为单元结构体（Unit Struct）。

以下是单元结构体的一些常见用途：

标记器（Marker）：单元结构体可以用作类型标记，用于表示某种特定的行为或特性。通过为类型添加不同的单元结构体，可以为其赋予不同的语义含义，以供代码中的其他部分使用。
占位符（Placeholder）：单元结构体可以占据某种类型的位置，但不需要存储实际的数据。这在某些上下文中是有用的，特别是当你需要使用类型系统或泛型来处理结构体，并且不需要实际的数据。
接口实现：单元结构体可以用作实现某个特定接口或特质所必需的类型。有时候，接口可能只需要表明一个行为或属性的存在，而不需要具体的数据内容，这时可以使用单元结构体。
占位参数：在某些情况下，你可能需要为泛型类型参数提供一个占位符。单元结构体可以用作泛型类型参数的占位符，以便稍后替换为具体的类型。

需要注意的是，尽管单元结构体自身没有任何字段，但你仍然可以为其实现方法、特质等。这样可以为其赋予更多的行为和功能。不过，大部分情况下，单元结构体的主要作用是在类型系统和语义上表达一些信息，而不是存储和处理具体的数据。

本文参考文章链接:https://www.runoob.com/rust/rust-struct.html