结构体可以用于组织不同类型的数据,和一些面向对像语言中的 是很像的。

这篇博客包含以下内容

  • 结构体的定义
  • 通过一个函数,创建并返回一个结构体
  • 定义一个结构体,但数据来自另外一个结构体
  • 元祖结构体

结构体的定义

1
2
3
4
5
6
7
#[derive(Debug)]  // 加上这一句,就可以使用 println!("{:?}", xxx); 打印
struct User {
username: String,
email: String,
sign_in_count: u64,
active: bool,
}

结构体以 struct 开头,后面是我们自定义的这个结构体类型的名字,里面每一个字段,以 字段名: 数据类型 的形式定义

结构体开头那个 #[derive(Debug)] 是为了打印而加的,也可以不加,这个的意思会在后面章节学习到,现在我也不知道具体意思,反正加上就可以使用 {:?} 的形式打印。

下面这段代码创建一个结构体实例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
fn main() {
let mut user = User {
username: String::from("someone"),
email: String::from("someone@outlook.com"),
sign_in_count: 1,
active: false,
};
// 打印这个结构体的内容
println!("{:?}", user);

// 因为创建 user 的时候加了 mut,所以可以修改里面字段的内容
user.active = true;
println!("Changed: {:?}", user);
}

通过一个函数,创建并返回一个结构体

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
fn build_user(_username: String, _email: String) -> User {
User {
username: _username,
email: _email,
sign_in_count: 2,
active: false,
}
}

// 如果参数名和结构体的字段名相同,则可以直接按下面的方式去赋值,
// 不需要再 aaa:bbb 这样的形式,并且顺序也无所谓
fn build_user2(username: String, email: String) -> User {
User {
email,
username,
sign_in_count: 2,
active: false,
}
}

定义一个结构体,但数据来自另外一个结构体

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
#[derive(Debug)]
struct User {
username: String,
email: String,
sign_in_count: u64,
active: bool,
}

fn main() {
let mut user = User {
username: String::from("someone"),
email: String::from("someone@outlook.com"),
sign_in_count: 1,
active: false,
};
println!("{:?}", user);

let user2 = User {
username: String::from("user2"),
email: String::from("user2@outlook.com"),
sign_in_count: user.sign_in_count, // 使用 user 实例的数据
active: user.active, // 这个也使用 user 实例的数据
};

// 除了 username 和 email, 其他字段都使用 user 的值
let user3 = User {
username: String::from("user3"),
email: String::from("user3@outlook.com"),
..user
};
}

上面的代码,使用其他结构体数据,创建新的结构体时,我们使用的都是 简单数据类型。如果使用 String 类型的字段,例如 username 或 email,则原有结构体实例的数据,会移动到新的结构体实例。看下面的代码。

下面这段代码编译会出错。

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
#[derive(Debug)]
struct User {
username: String,
email: String,
sign_in_count: u64,
active: bool,
}

fn main() {
let mut user = User {
username: String::from("someone"),
email: String::from("someone@outlook.com"),
sign_in_count: 1,
active: false,
};

let user2 = User {
..user
};

// !!!! 这一句编译会出错,因为我们创建 user2 的时候,使用了所有 user的数据,
// 因为 username 和 email是String类型的,所以 所有权 会移动到 user2的对应字段中
// 所以这句就会报错 !!!
println!("{:?}", user.username);
}

如果要修复错误,可以使用我们上一节学到的切片,直接看下面的代码

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
#[derive(Debug)]
struct User {
username: String,
email: String,
sign_in_count: u64,
active: bool,
}

fn main() {
let mut user = User {
username: String::from("someone"),
email: String::from("someone@outlook.com"),
sign_in_count: 1,
active: false,
};

let user2 = User {
username: String::from(&user.username[..]), // !!! 注意看这句
email: String::from(&user.email[..]), // !!! 还有这一句
..user
};

println!("{:?}", user.username);
println!("{:?}", user);
println!("{:?}", user2);
}

上面的代码,在创建 user2 时,String类型的字段,我们通过切片,创建了新的 String 数据,所以没有导致 所有权 转移。

元祖结构体

有一种结构体,没有具体的字段名,只有类型,这种结构体,称为 元祖结构体 (tuple structs)。看下面的代码

1
2
3
4
5
6
7
8
9
10
11
12
13
#[derive(Debug)]
struct Color(i32, i32, i32, i32);

fn main() {
let bg_color = Color(255, 0, 0, 255);
println!("{:?}", bg_color);

// 通过所引,访问结构体里的某个元素,与 元祖 的访问方式一样
let r = bg_color.0;
let g = bg_color.1;
let b = bg_color.2;
let a = bg_color.3;
}

这一节聊了一下结构体的基本知识,下一节将聊一下更多关于结构体的东西。