【Rust练习】11.struct

练习题来自：https://practice-zh.course.rs/compound-types/struct.html

1 对于结构体，我们必须为其中的每一个字段都指定具体的值

// fix the error
struct Person {name: String,age: u8,hobby: String
}
fn main() {let age = 30;let p = Person {name: String::from("sunface"),age,};
}

结构体的初始化，需要将每个字段都赋值才行。

struct Person {name: String,age: u8,hobby: String
}
fn main() {let age = 30;let p = Person {name: String::from("sunface"),age,hobby:String::from("sunface")};
}

题外话，Rust的结构体显然和C或者C++的结构体不太一样，对于C的结构体来说，不存在批量初始化这个说法，结构体都是基本类型，自带初值，赋值需要逐个字段；C++的结构体其实就是public class，初始化方式多种多样，还有面向对象的一系列特征。

而Rust并不是一个面向对象语言（至少它自己不觉得是）

2 🌟 单元结构体没有任何字段。

struct Unit;
trait SomeTrait {// ...定义一些行为
}// 我们并不关心结构体中有什么数据( 字段 )，但我们关心它的行为。
// 因此这里我们使用没有任何字段的单元结构体，然后为它实现一些行为
impl SomeTrait for Unit {  }
fn main() {let u = Unit;do_something_with_unit(u);
} // 填空，让代码工作
fn do_something_with_unit(u: __) {   }

trait是特征，后续会学到这个语法，目前来说可以当它不存在。这里u的类型是Unit

fn do_something_with_unit(u: Unit) {   }

3 🌟🌟🌟 元组结构体看起来跟元组很像，但是它拥有一个结构体的名称，该名称可以赋予它一定的意义。由于它并不关心内部数据到底是什么名称，因此此时元组结构体就非常适合。

// 填空并修复错误
struct Color(i32, i32, i32);
struct Point(i32, i32, i32);
fn main() {let v = Point(__, __, __);check_color(v);
}   fn check_color(p: Color) {let (x, _, _) = p;assert_eq!(x, 0);assert_eq!(p.1, 127);assert_eq!(__, 255);}

复习一下元组的两种访问方式：

1. 使用索引访问
2. 指定别名后，使用别名访问

元组结构体也一样，只是类似于C的typedef和C++的using，给元组起了一个别名。

struct Color(i32, i32, i32);
struct Point(i32, i32, i32);
fn main() {let v = Point(0, 127, 255);check_color(v);
}   fn check_color(p: Point) {let Point(x, y, z) = p;assert_eq!(x, 0);assert_eq!(p.1, 127);assert_eq!(z, 255);}

4 🌟 你可以在实例化一个结构体时将它整体标记为可变的，但是 Rust 不允许我们将结构体的某个字段专门指定为可变的.

// 填空并修复错误，不要增加或移除代码行
struct Person {name: String,age: u8,
}
fn main() {let age = 18;let p = Person {name: String::from("sunface"),age,};// how can you believe sunface is only 18? p.age = 30;// 填空__ = String::from("sunfei");
}

需要让p可变

fn main() {let age = 18;let mut p = Person {name: String::from("sunface"),age,};// how can you believe sunface is only 18? p.age = 30;// 填空p.name = String::from("sunfei");
}

Rust 不允许我们将结构体的某个字段专门指定为可变的

对应C++中的mutable，它的作用是，即使类的成员函数已经声明了const，使用mutable修饰的成员依然可以被修改，也就是“将结构体的某个字段专门指定为可变的”

我们有如下的代码：

struct testMut
{int changeNum() const{num++;return num;}private:int num = 0;
};

编译失败，原因：

testMut.cpp: In member function 'int testMut::changeNum() const':
testMut.cpp:9:9: error: increment of member 'testMut::num' in read-only object9 |         num++;|         ^~~

再给num加上mutable修饰：

mutable int num = 0;

就不会编译失败了。

很难说Rust的这个改进是否有意义，mutable的变量如果不看头文件的定义，再加上你用的IDE比较垃圾（点名eclipse C++），有时候真的意识不到变量被修改了。

5 🌟 使用结构体字段初始化缩略语法可以减少一些重复代码

// 填空
struct Person {name: String,age: u8,
}
fn main() {} fn build_person(name: String, age: u8) -> Person {Person {age,__}
}

答案如下：

struct Person {name: String,age: u8,
}
fn main() {} fn build_person(name: String, age: u8) -> Person {Person {age,name}
}

6 🌟 你可以使用结构体更新语法基于一个结构体实例来构造另一个

// 填空，让代码工作
struct User {active: bool,username: String,email: String,sign_in_count: u64,
}
fn main() {let u1 = User {email: String::from("someone@example.com"),username: String::from("sunface"),active: true,sign_in_count: 1,};let u2 = set_email(u1);
} fn set_email(u: User) -> User {User {email: String::from("contact@im.dev"),__}
}

有点像C++的继承，说实话我第一次知道继承还是从python，Rust的这个更加简洁一点。

fn set_email(u: User) -> User {User {email: String::from("contact@im.dev"),..u}
}

7 🌟🌟 我们可以使用 #[derive(Debug)] 让结构体变成可打印的.

// 填空，让代码工作
#[__]
struct Rectangle {width: u32,height: u32,
}fn main() {let scale = 2;let rect1 = Rectangle {width: dbg!(30 * scale), // 打印 debug 信息到标准错误输出 stderr,并将 `30 * scale` 的值赋给 `width`height: 50,};dbg!(&rect1); // 打印 debug 信息到标准错误输出 stderrprintln!(__, rect1); // 打印 debug 信息到标准输出 stdout
}

对于未继承Debug接口的struct，需要强制支持打印。

// 填空，让代码工作
#[derive(Debug)]
struct Rectangle {width: u32,height: u32,
}fn main() {let scale = 2;let rect1 = Rectangle {width: dbg!(30 * scale), // 打印 debug 信息到标准错误输出 stderr,并将 `30 * scale` 的值赋给 `width`height: 50,};dbg!(&rect1); // 打印 debug 信息到标准错误输出 stderrprintln!("{:?}", rect1); // 打印 debug 信息到标准输出 stdout
}

题外话，C++的format直到最近几代标准才加入，之前各个C++项目基本是在自己用第三方库打印，其实不如这种开箱即用的体验。至于cout？我觉得那个语法挺搞笑的，唯一优点是不需要像printf一样非得声明类型了。

8

// 修复错误
#[derive(Debug)]
struct File {name: String,data: String,
}
fn main() {let f = File {name: String::from("readme.md"),data: "Rust By Practice".to_string()};let _name = f.name;// 只能修改这一行println!("{}, {}, {:?}",f.name, f.data, f);
} 

f的name所有权已经转移走了，因此尝试打印name或者f本身都是不被允许的，但是f的data还是可用的。

#[derive(Debug)]
struct File {name: String,data: String,
}
fn main() {let f = File {name: String::from("readme.md"),data: "Rust By Practice".to_string()};let _name = f.name;// 只能修改这一行println!("{}, {}",_name, f.data);
}