Rust开发——Struct使用示例_rust struct 继承

结构体

1.定义

pub struct User
{
    user_id : u32,
    user_name: String,
    is_vip : bool,
}
1
2
3
4
5
6

2.实例化
这里初始化必须全部给所有的成员赋值，不像C++，可以单独初始化某个值

let user : User = User { user_id: 100, user_name: "matt".to_string(), is_vip: false};
1

简化赋值，结构体里的字段与声明赋值字段相同时可以省略字段名,后面的字面值不一样，所以必须指定字段名

	let user_id : u32 = 101;
    let user_name  = "matting".to_string();
    let vip = true;
    let user2:User = User { user_id, user_name, is_vip:vip};
1
2
3
4

3.获取值

let user_name = user.user_name;
1

4.可变访问，必须声明成可变的结构体才能可变访问，结构体里的所有元素都是可变的。

 let mut user : User = User { user_id: 100, user_name: "matt".to_string(), is_vip: false};
    
  user.user_name = "matt45m".to_string();
1
2
3

5.更新语法，基于某个实例创建一个新实例的时候，可以使用更新语法。…user代表后面的两个字段的值来自第一个结构体

 	let mut user : User = User { user_id: 100, user_name: "matt".to_string(), is_vip: false};
    let user_id : u32 = 101;
    
    let user2:User = User { user_id, ..user};
1
2
3
4

6.Tuple struct
Tuple struct 整体有指定的名字，但里面的元素没有名字。

 struct Color(u8,u8,u8);
 let black = Color(0,0,0);
1
2

7.struct的方法（rust的struct类似于c++的类）

• 方法是在struct（enum、trait对象）的上下文中定义的。
• 方法的第一个参数是self，self指向被调用的struct 实例（类似于C++的this指针）。
• 方法在 impl （implement）块中定义的 impl StructName {}
• 方法的第一个参数可以使 &self，也可以获得其所有权或可变借用，和其他参数一样。
• new方法可以构造struct,可以理解为构造函数

pub struct SlotNode
{
    user_name :String,
    start_node : u32,//开始节点
    end_node : u32,//结束节点
}

impl SlotNode 
{
    pub fn new() -> Self 
    {
       SlotNode { user_name: String::new(), start_node: 0, end_node: 1024}
    }

    pub fn get_end_node(&self) -> u32
    {
        self.end_node
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

实例化与访问

let slot_node = SlotNode::new();
 println!("{}\n", slot_node.get_end_node());
1
2

8.struct继承
rust struct的继承没有于C++那种强大的功能，而且概念上也有很大的差异，其实并不算传统意义上的继承。

// 定义一个类似于父类的结构体
#[derive(Debug)]
 struct Animal
{
    gender: String,
}
impl Animal 
{
     fn new(gender: String) -> Self 
     {
         Self { gender }
     }
 }
 impl Animal 
 {
     pub fn print_gender(&self) 
     {
         println!("Animal {}", self.gender);
     }

     fn set_gender(&mut self, gender: String) 
     {
         self.gender = gender;
     }
 }

// 定义子类
#[derive(Debug)]
struct Cat  
{
     animal: Animal,
     name: String,
 }
impl Cat  
{
     fn new(animal: Animal, name: &str) -> Self 
     {
        Self { animal , name: name.to_string()}
     }
 }
 impl Cat 
 {
     fn as_animal(&self) -> &Animal 
     {
         &self.animal
     }

     fn as_mut_animal(&mut self) -> &mut Animal 
     {
         &mut self.animal
     }
 }
 
 fn main() {
    let student = Animal::new("male".to_string());
    let mut tome = Cat ::new(student, "小橘");

    tome.animal.print_gender();
    tome.animal.set_gender("femininity".to_string());
    tome.animal.print_gender();

    println!("{:#?}", tome);

    let a: &Animal = tome.as_animal();
    a.print_gender();
    let a: &mut Animal = tome.as_mut_animal();
    a.set_gender("femininity".to_string());
    a.print_gender();
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70