Rust 结构体

Licodeao2024-01-13 10:30

结构体

struct 是一个自定义数据类型，允许你包装和命名多个相关的值，从而形成一个有意义的组合。

定义和实例化

结构体的每一部分都可以是不同类型，不同于元组，结构体需要命名各部分数据以便能清楚的表明其意义，有了这些名字，结构体比元组更加灵活，不需要依赖顺序来指定或访问实例中的值。

定义结构体，需要使用 struct 关键字，并给整个结构体提供一个名字。接着需要在结构体中定义每一部分数据的名字和类型，这些数据称为字段（field）。

rust 复制代码 
struct User {
  username: String,
  age: u32,
  gender: String,
  is_active: bool,
}

定义好结构体后，通过为每个字段指定具体值来创建这个结构体的实例。实例中字段的顺序不需要和它们在结构体中声明的顺序一致。

rust 复制代码 
fn main() {
  let mut user = User {
    username: String::from("Licodeao"),
    age: 21,
    gender: String::from("Male"),
    is_active: true,
  };
}

可以使用点号从结构体中获取特定的值，修改原有值时，该结构体实例必须是可变的，不能只是某个字段是可变的，要整体可变。

rust 复制代码 
struct User {
  username: String,
  age: u32,
  gender: String,
  is_active: bool,
}

fn main() {
  let mut user = User {
    username: String::from("Licodeao"),
    age: 21,
    gender: String::from("Male"),
    is_active: true,
  };

  user.username = String::from("licodeao@gmail.com");
  user.age = 30;
  user.gender = String::from("Unknown");
  user.is_active = false;
}

返回结构体

rust 复制代码 
fn main() {
  fn return_user(username: String, gender: String) -> User {
    User {
      username: username,
      age: 21,
      gender: gender,
      is_active: true,
    }
  }

  let return_user = return_user(String::from("Licodeao"), String::from("Male"));

  println!("Username: {}", return_user.username);
}

字段初始化简写语法（field in shorthand）

（与 ES6 中对象增强中的属性增强简直一模一样...）

rust 复制代码 
fn main() {
  fn return_user(username: String, gender: String) -> User {
    User {
      username,
      age: 21,
      gender,
      is_active: true,
    }
  }

  let return_user = return_user(String::from("Licodeao"), String::from("Male"));

  println!("Username: {}", return_user.username);
}

创建新实例

通过结构体创建新的实例，除了使用旧实例的大部分值但是改变其部分值来创建，还可以通过结构体更新语法（struct update syntax）

（与 ES6 中的扩展运算符简直一模一样，只是少了个点...）

.. 语法指定了剩余未显式设置值的字段应有与给定实例对应字段相同的值。

rust 复制代码 
struct User {
  username: String,
  age: u32,
  gender: String,
  is_active: bool,
}

fn main() {
  let user = User {
    username: String::from("Licodeao"),
    age: 21,
    gender: String::from("Male"),
    is_active: true,
  };

  let user2 = User {
    username: String::from("licodeao@gmail.com"),
    // 结构体更新语法
    ..user
  };

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

⚠️：结构更新语法就像带有 = 的赋值，因为它移动了数据，总体上说我们在创建 user2 后不能就再使用 user1 了

没有命名的元组结构体

定义与元组类似的结构体，称为元组结构体。元组结构体有结构体名称，但是没有具体的字段名，只有字段类型。

rust 复制代码 
struct Color(u32, u32, u32);
struct Point(i32, i32, i32);

fn main() {
  let red = Color(255, 255, 255);
  let origin = Point(100, -100, -255);
}

没有任何字段的类单元结构体

定义一个没有任何字段的结构体，称为类单元结构体（unit-like structs），因为它类似于 () 。

类单元结构体常常在你想要在某个类型上实现 trait ，但不需要在类型中存储数据时发挥作用。

rust 复制代码 
struct UnitLikeStruct;

fn main() {
  let unit_like_struct = UnitLikeStruct;
}

结构体中的所有权

当结构体中存储被其他对象拥有的数据的引用时，需要用上生命周期（lifetimes）。

如果尝试在结构体中存储一个引用而不指定生命周期，这将会是无效的。

rust 复制代码 
struct User {
    active: bool,
    username: &str,
    email: &str,
    sign_in_count: u64,
}

fn main() {
    let user1 = User {
        active: true,
        username: "LICODEAO",
        email: "licodeao@gmail.com",
        sign_in_count: 1,
    };
}

会出现以下错误：

rust 复制代码 
 --> src/main.rs:3:13
  |
3 |   username: &str,
  |             ^ expected named lifetime parameter
  |
help: consider introducing a named lifetime parameter
  |
1 ~ struct User<'a> {
2 |   active: bool,
3 ~   username: &'a str,
  |

error[E0106]: missing lifetime specifier
 --> src/main.rs:4:10
  |
4 |   email: &str,
  |          ^ expected named lifetime parameter
  |
help: consider introducing a named lifetime parameter
  |
1 ~ struct User<'a> {
2 |   active: bool,
3 |   username: &str,
4 ~   email: &'a str,
  |

编译器会提示它需要生命周期标识符...

打印结构体

rust 复制代码 
struct Rectangle {
  width: u32,
  height: u32,
}

fn main() {
  let rect1 = Rectangle {
      width: 30,
      height: 50,
  };

  println!("rect1 is {}", rect1);
}

运行上方代码后，会出现以下问题：

rust 复制代码 
error[E0277]: `Rectangle` doesn't implement `std::fmt::Display`

println! 宏能处理很多类型的格式，不过 {} 告诉 println! 宏使用被称为 Display 的格式，它像用户展示 1 或其他任何基本类型的唯一方式。不过对于结构体，println! 并没有提供一个 Display

在 {} 中加入 :? 提示符告诉 println! 使用 Debug 的输出格式，Debug 是一个 trait，必须显式地为结构体标注要使用 Debug

rust 复制代码 
// 增加外部属性来派生 Debug trait
#[derive(Debug)]
struct Rectangle {
  width: u32,
  height: u32,
}

fn main() {
  let rect1 = Rectangle {
      width: 30,
      height: 50,
  };

  println!("rect1 is {:?}", rect1); // rect1 is Rectangle { width: 30, height: 50 }
}

使用 {:#?} 替换 {:?} ，能够看到更漂亮和易读的输出

rust 复制代码 
#[derive(Debug)]
struct Rectangle {
  width: u32,
  height: u32,
}

fn main() {
  let rect1 = Rectangle {
      width: 30,
      height: 50,
  };

  println!("rect1 is {:#?}", rect1);
}
rust 复制代码 
rect1 is Rectangle {
    width: 30,
    height: 50,
}

方法语法

方法与函数类似：都可以使用 fn 关键字和名称声明，并且可以拥有参数和返回值，同时包含在某处调用时会执行的代码。

方法与函数不同的是：方法在结构体的上下文、枚举、trait 对象中被定义，并且它们第一个参数永远是 self ，它代表调用该方法的结构体实例。

定义方法

rust 复制代码 
#[derive(Debug)]
struct Rectangle {
  width: u32,
  height: u32,
}

impl Rectangle {
  // 方法语法，self 指向 rect1这个结构体实例
  fn area(&self) -> u32 {
      self.width * self.height
  }
}

fn main() {
  let rect1 = Rectangle {
      width: 30,
      height: 50,
  };

  println!("rect1 is {:?}", rect1.area());
}

使用 &self 来替代 rectangle: &Rectangle ，&self 实际上是 self: &Self 的缩写。

在一个 impl 块中，Self 类型是 impl 块的类型的别名。方法的第一个参数必须有一个名为 self 的 Self 类型的参数。

方法可以与字段同名：

rust 复制代码 
#[derive(Debug)]
struct Rectangle {
  width: u32,
  height: u32,
}

impl Rectangle {
  fn width(&self) -> bool {
    self.width > 0
  }
}

fn main() {
  let rect1 = Rectangle {
      width: 30,
      height: 50,
  };

  if rect1.width() {
    println!("rect1 width is {:?}", rect1.width);
  }
}

当在 rect1.width 后面加上括号时，Rust 知道指的是方法 width；当不使用圆括号时，Rust 知道指的是字段 width

与字段同名的方法将被定义为只返回字段中的值，而不做其他事情，这样的方法被称为 getters

关联函数

所有在 impl 块中定义的函数被称为关联函数，因为它们与 impl 后面命名的类型相关。

可以定义不以 self 为第一个参数的关联函数，因此它不是一个方法，因为它并不作用于一个结构体实例。

不是方法的关联函数经常被用作返回一个结构体新实例的构造函数。

rust 复制代码 
impl Rectangle {
  fn square(size: u32) -> Self {
    Self {
      width: size,
      height: size,
    }
  }
}

关键字 Self 在函数的返回类型中代指在 impl 关键字后出现的类型，这里指的是 Rectangle ，即 Self 指的是 Rectangle

使用结构体和 :: 来调用这个关联函数，如 Rectangle::square(6)

多个 impl 块

每个结构体都允许有多个 impl 块。

每个方法有其自己的 impl 块。

rust 复制代码 
impl Rectangle {
  fn area(&self) -> u32 {
    self.width * self.height
  }
}

impl Rectangle {
  fn can_hold(&self, other: &Rectangle) -> bool {
    self.width > other.width && self.height > other.height
  }
}

使用结构体能够方便地组装数据，使得代码更加清晰，但结构体并不是创建自定义类型的唯一方法，还可以使用枚举。

相关推荐
itas10910 小时前
Rust调用C动态库
c语言·rust·bindgen·bindings·rust c绑定
SomeB1oody10 小时前
【Rust自学】5.1. 定义并实例化struct
开发语言·后端·rust
m0_7482361114 小时前
Calcite Web 项目常见问题解决方案
开发语言·前端·rust
SomeB1oody2 天前
【Rust自学】4.1. 所有权：栈内存 vs. 堆内存
开发语言·后端·rust
SomeB1oody2 天前
【Rust自学】4.2. 所有权规则、内存与分配
开发语言·后端·rust
SomeB1oody2 天前
【Rust自学】4.5. 切片（Slice）
开发语言·后端·rust
编码浪子3 天前
构建一个rust生产应用读书笔记6-拒绝无效订阅者02
开发语言·后端·rust
baiyu333 天前
1小时放弃Rust(1): Hello-World
rust
baiyu333 天前
1小时放弃Rust(2): 两数之和
rust
Source.Liu3 天前
数据特性库 前言
rust·cad·num-traits
热门推荐
01构建高效的广告投放系统：应用架构的设计与实现02ARM学习（31）编译器对overlay方式的支持03玄机平台应急响应—webshell查杀04Cube-Studio：开源大模型全链路一站式中台05校验 GPT-4 真实性的三个经典问题：快速区分 GPT-3.5 与 GPT-4，并提供免费测试网站06Docker 夺命连环 15 问07〔AI 绘画〕Stable Diffusion 之 解决绘制多人或面部很小的人物时面部崩坏问题 篇08基于大语言模型（LLM）的合成数据生成、策展和评估的综述09(欧拉)openEuler系统添加网卡文件配置流程、(欧拉)openEuler系统手动配置ipv6地址流程、(欧拉)openEuler系统网络管理说明10Ubuntu 20.04使用Livox mid 360 测试 FAST_LIO