21.结构体(Struct)

结构体（ struct ）可以由各种不同类型组成。使用 struct 关键字来创建。struct 是 structure 的缩写。结构体可以作为另一个结构体的字段。结构体是可以嵌套的。

  • 元组结构体（tuple struct），事实上就是具名元组而已。

    1
    struct Pair(String, i32);

  • 经典的 C 语言风格结构体（C struct）。

    1
    2
    3
    struct 结构体名称 {
        ...
    }

  • 单元结构体（unit struct），不带字段，在泛型中很有用。

    1
    struct Unit;

定义结构体

1
2
3
4
5
struct 结构体名称 {
    字段1:数据类型,
    字段2:数据类型,
    ...
}

创建结构体实例

1
2
3
4
5
let 实例名称 = 结构体名称{
    field1:value1,
    field2:value2
    ...
};

结构体初始化，其实就是对 结构体中的各个元素进行赋值。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
#[derive(Debug)]
struct Study {
    name: String,
    target: String,
    spend: i32,
}

fn main() {
    let s = Study {
        name: String::from("从0到Go语言微服务架构师"),
        target: String::from("全面掌握Go语言微服务落地，代码级一次性解决微服务和分布式系统。"),
        spend: 3,
    };
    println!("{:?}", s);
    //输出 Study { name: "从0到Go语言微服务架构师", target: "全面掌握Go语言微服务落地，代码级一次性解决微服务和分布式系统。", spend: 3 }
}

访问实例属性

1
2
3
实例名称.属性

println!("{}",s.name);//输出 从0到Go语言微服务架构师

修改结构体实例

结构体实例默认是不可修改的，如果想修改结构体实例，声明时使用mut关键字。

1
2
3
4
5
6
7
let mut s2 = Study {
        name: String::from("从0到Go语言微服务架构师"),
        target: String::from("全面掌握Go语言微服务落地，代码级一次性解决微服务和分布式系统。"),
        spend: 3,
    };
 s2.spend=7;
 println!("{:?}",s2);//输出 Study { name: "从0到Go语言微服务架构师", target: "全面掌握Go语言微服务落地，代码级一次性解决微服务和分布式系统。", spend: 7 }

结构体做参数

1
2
3
4
5
6
fn show(s: Study) {
    println!(
        "name is :{} target is {} spend is{}",
        s.name, s.target, s.spend
    );
}

结构体作为返回值

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
fn get_instance(name: String, target: String, spend: i32) -> Study {
    return Study {
        name,
        target,
        spend,
    };
}

let s3 = get_instance(
    String::from("Go语言极简一本通"),
    String::from("学习Go语言语法，并且完成一个单体服务"),
    5,
);
println!("{:?}", s3);
//输出 Study { name: "Go语言极简一本通", target: "学习Go语言语法，并且完成一个单体服务", spend: 5 }

方法

方法（method）是依附于对象的函数。这些方法通过关键字 self 来访问对象中的数据和其他。方法在 impl 代码块中定义。

与函数的区别

函数：可以直接调用，同一个程序不能出现 2 个相同的函数签名的函数，应为函数不归属任何 owner。

方法：归属某一个 owner，不同的 owner 可以有相同的方法签名。

1
2
3
4
5
impl 结构体{
    fn 方法名(&self,参数列表) 返回值 {
        //方法体
    }
}

impl 是 implement 的缩写。意思是 “实现”的意思。

self 是“自己”的意思，&self 表示当前结构体的实例。 &self 也是结构体普通方法固定的第一个参数，其他参数可选。

结构体方法的作用域仅限于结构体内部。

1
2
3
4
5
6
7
8
impl Study {
    fn get_spend(&self) -> i32 {
        return self.spend;
    }
}

println!("spend {}", s3.get_spend());
//输出 spend 5

结构体静态方法

1
2
3
4
5
6
fn 方法名(参数: 数据类型,...) -> 返回值类型 {
      // 方法体
   }

调用方式
结构体名称::方法名(参数列表)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

impl Study {
    ...
    fn get_instance_another(name: String, target: String, spend: i32) -> Study {
        return Study {
            name,
            target,
            spend,
        };
    }
}

let s4 = Study::get_instance_another(
    String::from("Go语言极简一本通"),
    String::from("学习Go语言语法，并且完成一个单体服务"),
    5,
);

单元结构体
unit type 是一个类型，有且仅有一个值：()，单元类型()类似 c/c++/java 语言中的 void。当一个函数并不需要返回值的时候，rust 则返回()。但语法层面上，void 仅仅只是一个类型，该类型没有任何值；而单元类型()既是一个类型，同时又是该类型的值。

实例化一个元组结构体

1
let pair = (String::from("从0到Go语言微服务架构师"), 1);

访问元组结构体的字段

1
println!("pair 包含 {:?} and {:?}", pair.0, pair.1);

解构一个元组结构体

1
2
let (study, spend) = pair;
println!("pair contains {:?} and {:?}", study, spend);

添加微信 公众号更多内容
wechat gzh