rust学习六、RUST struct结构类型

rust的struct结构体是一个不错的东西，不像java，后者在17版本左右才可用。
有许多语言都有类似的东西，例如pascal有record。
在rust中，struct大体等于java的class,c#的class。
 
本文主要根据相关章节编写。
一、结构定义

struct-翻译为结构/结构体
总体上有两种定义方式：带有详细属性名的；不带属性名（元组）
从工程角度出发，并不推荐不带属性的定义方式，因为不友好。希望rust后面不要搞类似好像很友好，但是其实起到干扰作用的语法。
如果再考虑到一些rust的其它问题，定义一个结构其实也不是那么容易。
示例：

1. struct Point{x:f64,y:f64}
2. struct Triangle(Point,Point,Point);
4. /**
5. * 家庭结构体s
6. */
7. struct Family {
8.     name: String,
9.     father: String,
10.     mather: String,
11.     children: Vec<String>,
12. }
13. /**
14. * 这都什么狗屎语法。
15. */
16. struct Book<'a> {
17.     name: &'a str,
18.     author: &'a str,
19.     price: f64,
20.     pubyear: i32,
21. }
24. fn main() {
25.     let mut family = Family {
26.         name: String::from("家"),
27.         father: String::from("爸爸"),
28.         mather: String::from("妈妈"),
29.         children: vec![],
30.     };
32.     family.children.push(String::from("老大-独龙"));
33.     family.children.push(String::from("老二-独眼"));
34.     family.children.push(String::from("老三-独秀"));
35.     family.children.push(String::from("老四-嘟嘟"));
36.     family.children.push(String::from("老五-杜牧"));
38.     //打印家庭结构体
39.     println!(
40.         "家庭:{},父亲:{},母亲:{}",
41.         family.name, family.father, family.mather
42.     );
43.     for child in &family.children {
44.         println!("孩子:{}", child);
45.     }
48.     let mut 三国演义 = Book {
49.         name: "三国演义",
50.         author: "罗贯中",
51.         price: 29.8,
52.         pubyear: 1300,
53.     };
54.    
55.     //各种创建结构实例的方式
56.     // 方式一：双点号复制
57.     let mut 红楼梦=Book{
58.         name:"红楼梦",
59.         author:"曹雪芹",
60.         ..三国演义
61.     };
62.     //方式二: 略属性名
63.     let 西游记=write_book("西游记","吴承恩",24.0,1525);
64.     //方式三:使用基于元组定义的。 比java的record还简单
66.     let books=[三国演义,红楼梦,西游记];
67.     for i in 0..books.len() {
68.         print_book(&books[i]);
69.     }
70.     let p1=Point{x:10.0,y:20.0};
71.     let p2=Point{x:20.0,y:20.0};
72.     let p3=Point{x:20.0,y:10.0};
73.     let t=Triangle(p1,p2,p3);
74.     print_triangle(&t);
75. }
77. fn print_book(book:&Book){
78.     println!(
79.         "书名:{},作者:{},价格:{},出版年:{}",
80.         book.name, book.author, book.price, book.pubyear
81.     );
82. }
84. fn print_triangle(t:&Triangle){
85.     println!("三点坐标:");
86.     println!("{},{}",t.0.x,t.0.y);
87.     println!("{},{}",t.1.x,t.1.y);
88.     println!("{},{}",t.2.x,t.2.y);
89. }
91. fn write_book<'a>(name:&'a str,author:&'a str,price:f64,pubyear:i32)->Book<'a>{
92.     Book{
93.         name,
94.         author,
95.         price,
96.         pubyear
97.     }
98. }

复制代码

 二、几种打印方式

至少有4种打印方式：

• 逐一访问属性名
  
• println!使用宏符号:?
  
• println!使用宏符号:#?
  
• 使用dbg!
  

后面三种方式，要求定义结构的时候，在结构前添加
#[derive(Debug)]
这个东西应该怎么称呼了？ "属性"还是"编译指示符"?，有点乱七八杂的。 从宏观上而言，很多类似的都是可以称为编译指示符，所以为了更加精准一些，我愿意称为"功能编译指示"。通过这个功能编译指示，rust编译器会自动实现特定功能。  示例：

1. let mut 红楼梦=Book{
2.         name:"红楼梦",
3.         author:"曹雪芹",
4.         ..三国演义
5.     };

复制代码

 
三、定义结构内的函数

在没有看书本正文之前，我以为和java的record一样，在struct内部定义函数。
其实不是！ 如果要为结构体定义函数，必须在结构体外。 不知道为什么要那样？ 难道内部定义的话，有其它用途？
示例：

1. #[derive(Debug)]
2. struct Family{
3.     father:String,
4.     mather:String,
5.     address:String
6. }
8. fn main(){
9.     let mut mf=Family{
10.         father:String::from("lu"),
11.         mather:String::from("hu"),
12.         address:String::from("中国")
13.     };
14.     println!("我家-{},{},{}",mf.father,mf.mather,mf.address);
15.     print_family(&mf);
16.     print_family_use_dbg(&mf);
17. }
19. fn print_family(f:&Family){
20.     //你不能直接打印，否则会有奇奇怪怪的错误提示
21.     //println!("{}",f);  // 这个会提示错误，所以注释掉了
23.     //使用奇怪符号 :?打印结构体
24.     println!("我家:?-{:?}",f);
26.     //使用奇怪的符号，可以打印结构体 :#?
27.     println!("我家:#?-{:#?}",f);
28. }
30. fn print_family_use_dbg(f:&Family){
31.     dbg!(f);
32. }

复制代码

 
结构体的函数有几个特点：

• 在结构体外，使用impl xxxx {}的方式，其中xxx是结构体名称
  
• 在一个impl xxx{}结构中，可以定义多个函数
  
• 书本建议我们：函数的第一个方法总是 &self,这点和python有点类似
  
• 参数&self虽然有定义，但是调用的时候不需要显示传递，因为这是编译器实现的
  

 
四、一点小补充

4.1定义没有成员的结构

在很多OOP，允许我们定义没有成员的对象。
我们可以把struct大体当做对象。
在rust中也可以定义没有成员的结构，例如：

1. #[derive(Debug)]
2. struct Cube{
3.     length: u32,
4.     width: u32,
5.     height: u32,
6. }
7. impl Cube{
8.     fn volume(&self) -> u32{
9.         return self.length * self.width * self.height;
10.     }
11.     fn is_bigger_than(&self, other: &Cube) -> bool{
12.         return self.volume() > other.volume();
13.     }
15. }
17. fn main() {
18.     let cube = Cube{length: 10, width: 12, height: 25};
19.     let cube2 = Cube{length: 15, width: 10, height: 30};
20.     println!("立方体的体积={}立方厘米",cube.volume());
21.     let is_bigger = cube.is_bigger_than(&cube2);
22.     match is_bigger{
23.         true => println!("cube的体积{}大于cube2体积{}",cube.volume(), cube2.volume()),
24.         false =>println!("cube的体积{}小于cube2体积{}",cube.volume(), cube2.volume()),
25.     };
26. }

复制代码

 
rust允许这样做，是因为struct这个类型具有很多作用，即使它不用于存储数据，也有很多作用。具体什么作用，只能等待深入后了解。
总之在rust中，绝大部分复杂的类型，都是基于结构定义的。
4.2struct大有作用

前有言：某种程度上可以把struct视为OOP中的对象
虽然rust不是明面上的OOP，但还是吸收了很多OOP的营养。
总之，许多复杂类型都是基于结构定义的。具体不一一罗列。
五、小结

结构体无疑是一个有用的东西，它就算垃圾袋/宝物袋一样，什么都可以往里装，大大方便了工程师！
 

来源：程序园用户自行投稿发布，如果侵权，请联系站长删除
免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！