【Rust中级教程】2.8. API设计原则之灵活性(flexible) Pt.4：显式析构函数的问题及3种解决方案

devtools/2025/2/26 19:12:52/

喜欢的话别忘了点赞、收藏加关注哦（加关注即可阅读全文），对接下来的教程有兴趣的可以关注专栏。谢谢喵！(=･ω･=)
请添加图片描述
说句题外话，这篇文章一共5721个字，是我截至目前写的最长的一篇文章，看我这么努力，还不点赞、收藏加关注？
请添加图片描述

2.8.1. 显式析构函数的问题

添加显式析构函数时会遇到问题：

  • 当某一类型实现了Drop，在析构函数中无法将该类型的任何字段移出。因为在显式析构函数运行后，drop()仍会被调用，它接受&mut self，要求self的所有部分都没被移动。
  • Drop接收的是&mut self而不是self，因此Drop无法实现简单地调用显式析构函数并忽略其结果(因为Drop不拥有self)

以上一篇文章的例子为基础，如果我们加上既实现了Drop trait，又写了close方法：

rust">use std::os::fd::AsRawFd;  
use std::fs::{File as StdFile, OpenOptions, metadata};  
use std::io::Error;  /// 一个表示文件句柄的类型  
struct File {  /// 文件名  name: String,  /// 文件描述符  fd: i32,  
}  impl File {  /// 一个构造函数，打开一个文件并返回一个 File 实例  fn open(name: &str) -> Result<File, Error> {  // 使用 OpenOptions 打开文件，具备读写权限  let file: StdFile = OpenOptions::new()  .read(true)  .write(true)  .open(name)?;  // 获取文件描述符  let fd: i32 = file.as_raw_fd();  // 返回一个 File 实例  Ok(File {  name: name.to_string(),  fd,  })  }  /// 一个显式的析构函数，关闭文件并返回任何错误  fn close(self) -> Result<(), Error> {  // 使用 FromRawFd 将 fd 转换回 File        let file: std::fs::File = unsafe {   std::os::unix::io::FromRawFd::from_raw_fd(self.fd)   };  // 刷新文件数据到磁盘  file.sync_all()?;  // 将文件截断为 0 字节  file.set_len(0)?;  // 再次刷新文件  file.sync_all()?;  // 丢弃文件实例，它会自动关闭文件  drop(file);  // 返回成功  Ok(())  }  
}  //实现drop trait  
impl Drop for File {  fn drop(&mut self) {  let _ = self.close();  //调用close方法来丢弃  println!("File dropped");  }  
}  fn main() {  // 创建一个名为 "test.txt" 的文件，并写入一些内容  std::fs::write("test.txt", "Hello, world!").unwrap();  // 打开文件并获取 File 实例  let file: File = File::open("test.txt").unwrap();  // 打印文件名和 fd    println!("File name: {}, fd: {}", file.name, file.fd);  // 关闭文件并处理任何错误  match file.close() {  Ok(()) => println!("File closed successfully"),  Err(e) => println!("Error closing file: {}", e),  }  // 检查关闭后的文件大小  let metadata = metadata("test.txt").unwrap();  println!("File size: {} bytes", metadata.len());  
}

输出：

error[E0507]: cannot move out of `*self` which is behind a mutable reference--> src/main.rs:59:17|
59 |         let _ = self.close();  //调用close方法来丢弃|                 ^^^^ ------- `*self` moved due to this method call|                 ||                 move occurs because `*self` has type `File`, which does not implement the `Copy` trait|
note: `File::close` takes ownership of the receiver `self`, which moves `*self`--> src/main.rs:33:14|
33 |     fn close(self) -> Result<(), Error> {|              ^^^^
note: if `File` implemented `Clone`, you could clone the value--> src/main.rs:6:1|
6  | struct File {| ^^^^^^^^^^^ consider implementing `Clone` for this type
...
59 |         let _ = self.close();  //调用close方法来丢弃|                 ---- you could clone this value

报错信息显示无法从*self中移出值，因为它位于&mut self后面。

2.8.2. 解决方案

首先需要说明的是没有完美的解决方案，我们只能尽力弥补。

解决方案1：把结构体包装Option<T>里然后再套一层结构体

我们可以将顶层方案作为包装了Option<T>的新类型，这样Option<T>内部持有一个类型，这个类型包含所有的字段。

这个时候我们就需要两个析构函数，外边一个里面一个。在这两个析构函数中使用Option::take函数来获取数据所有权从而移除值。

由于内部类型没有实现Drop，所以你可以获取所有字段的所有权。

缺点：想在顶层类型上提供的所有方法，现在都必须添加通过Option<T>这层壳来获取内部类型上字段的代码。

我们在上文的代码例基础上进行修改：

步骤1：改掉File的定义，套一层壳

首先我们得把两个字段移到另一个结构体里，套在Option<T>中作为File结构体的字段

rust">/// 一个表示文件句柄的类型  
struct InnerFile {  /// 文件名  name: String,  /// 文件描述符  fd: i32,  
}  /// 给InnerFile套了一个壳  
struct File {  /// 把InnerFile包装在Option<T>中  inner: Option<InnerFile>,  
}

步骤2：修改File上的方法

File上有两个方法，我们都需要添加通过Option<T>这层壳来获取内部类型上字段的代码。

首先是open方法：

rust">/// 一个构造函数，打开一个文件并返回一个 File 实例  
fn open(name: &str) -> Result<File, Error> {  // 使用 OpenOptions 打开文件，具备读写权限  let file: StdFile = OpenOptions::new()  .read(true)  .write(true)  .open(name)?;  // 获取文件描述符  let fd: i32 = file.as_raw_fd();  // 返回一个 File 实例  Ok(File {  inner: Some( InnerFile {  name: name.to_string(),  fd,  })  })  
}
  • 由于这个代码只有返回值设计了File结构体，所以也只有返回值需要改

接下来是close方法：

rust">/// 一个显式的析构函数，关闭文件并返回任何错误  
fn close(mut self) -> Result<(), Error> { // 记得self要变为mut self，否则take不了  // 使用模式匹配提取出字段的值  if let Some(inner) = self.inner.take() {  let name = inner.name;  let fd = inner.fd;  println!("Closing file: {} with fd: {}", name, fd);  // 使用 FromRawFd 将 fd 转换回 File        let file: std::fs::File = unsafe {  std::os::unix::io::FromRawFd::from_raw_fd(fd)  };  // 刷新文件数据到磁盘  file.sync_all()?;  // 将文件截断为 0 字节  file.set_len(0)?;  // 再次刷新文件  file.sync_all()?;  // 丢弃文件实例，它会自动关闭文件  drop(file);  // 返回成功  Ok(())  } else {  // 如果inner字段是None，说明文件已经被关闭或丢弃，返回错误  Err(Error::new(  std::io::ErrorKind::Other,  "File is already closed",  ))  }  
}
  • 参数传进去之后先得通过模式匹配来获取字段的值
  • 如果如果inner字段是None，也就是模式匹配不成功的情况下，我们需要自己写一个错误返回

步骤3：修改Drop trait的实现

Drop::drop方法需要修改:

rust">fn drop(&mut self) {  // 使用模式匹配获取字段值  if let Some(inner) = self.inner.take() {  let name = inner.name;  let fd = inner.fd;  println!("Dropping file: {} (fd: {})", name, fd);  // 使用 FromRawFd 将 fd 转换回 File        let file: std::fs::File = unsafe {  std::os::unix::io::FromRawFd::from_raw_fd(fd)  };  // 丢弃file实例  drop(file);  } else {  // 如果inner字段是None的话，说明文件已经被丢弃或关闭，不做任何操作  }  
}
  • 参数传进去之后先得通过模式匹配来获取字段的值
  • 如果inner字段是None的话，说明文件已经被丢弃或关闭，不做任何操作

步骤4：微修主函数

主函数中需要提取字段值的地方需要修改：

rust">fn main() {// ...前文无修改，已省略// 打印文件名和 fd (这里需要修改)  println!("File name: {}, fd: {}",   file.inner.as_ref().unwrap().name,  file.inner.as_ref().unwrap().fd  );// ...后文无修改，已省略
}
  • 原始类型是 Option<InnerFile>，调用.as_ref()后变成Option<&InnerFile>
  • 变成了Option<&InnerFile>再使用unwrap提取出来的值就是引用而不是所有的值
  • file.inner是一个Option<InnerFile>类型。而直接访问Option的值需要转移所有权或匹配处理（例如通过 take() 或 unwrap()），这会销毁Option的内部值，所以得要as_ref

整体代码

rust">use std::os::fd::AsRawFd;  
use std::fs::{File as StdFile, OpenOptions, metadata};  
use std::io::Error;  /// 一个表示文件句柄的类型  
struct InnerFile {  /// 文件名  name: String,  /// 文件描述符  fd: i32,  
}  /// 给InnerFile套了一个壳  
struct File {  /// 把InnerFile包装在Option<T>中  inner: Option<InnerFile>,  
}  impl File {  /// 一个构造函数，打开一个文件并返回一个 File 实例  fn open(name: &str) -> Result<File, Error> {  // 使用 OpenOptions 打开文件，具备读写权限  let file: StdFile = OpenOptions::new()  .read(true)  .write(true)  .open(name)?;  // 获取文件描述符  let fd: i32 = file.as_raw_fd();  // 返回一个 File 实例  Ok(File {  inner: Some( InnerFile {  name: name.to_string(),  fd,  })  })  }  /// 一个显式的析构函数，关闭文件并返回任何错误  fn close(mut self) -> Result<(), Error> { // 记得self要变为mut self，否则take不了  // 使用模式匹配提取出字段的值  if let Some(inner) = self.inner.take() {  let name = inner.name;  let fd = inner.fd;  println!("Closing file: {} with fd: {}", name, fd);  // 使用 FromRawFd 将 fd 转换回 File            let file: std::fs::File = unsafe {  std::os::unix::io::FromRawFd::from_raw_fd(fd)  };  // 刷新文件数据到磁盘  file.sync_all()?;  // 将文件截断为 0 字节  file.set_len(0)?;  // 再次刷新文件  file.sync_all()?;  // 丢弃文件实例，它会自动关闭文件  drop(file);  // 返回成功  Ok(())  } else {  // 如果inner字段是None，说明文件已经被关闭或丢弃，返回错误  Err(Error::new(  std::io::ErrorKind::Other,  "File is already closed",  ))  }  }  
}  // 实现drop trait，用于在值离开作用域时运行的一些代码  
impl Drop for File {  fn drop(&mut self) {  // 使用模式匹配获取字段值  if let Some(inner) = self.inner.take() {  let name = inner.name;  let fd = inner.fd;  println!("Dropping file: {} (fd: {})", name, fd);  // 使用 FromRawFd 将 fd 转换回 File            let file: std::fs::File = unsafe {  std::os::unix::io::FromRawFd::from_raw_fd(fd)  };  // 丢弃file实例  drop(file);  } else {  // 如果inner字段是None的话，说明文件已经被丢弃或关闭，不做任何操作  }  }  
}  fn main() {  // 创建一个名为 "test.txt" 的文件，并写入一些内容  std::fs::write("test.txt", "Hello, world!").unwrap();  // 打开文件并获取 File 实例  let file: File = File::open("test.txt").unwrap();  // 打印文件名和 fd (这里需要修改)  println!("File name: {}, fd: {}",   file.inner.as_ref().unwrap().name,  file.inner.as_ref().unwrap().fd  );  // 关闭文件并处理任何错误  match file.close() {  Ok(()) => println!("File closed successfully"),  Err(e) => println!("Error closing file: {}", e),  }  // 检查关闭后的文件大小  let metadata = metadata("test.txt").unwrap();  println!("File size: {} bytes", metadata.len());  
}

解决方案2：把字段包装在Option<T>里

我们也可以保持结构体不变，把每个字段的值都套在Option<T>里，需要获取所有权使用时用Option::take就可以，需要引用时用.as_ref()加.unwrap()就可以。

如果类型具有合理的空值，那么效果很好。

缺点：如果你必须将几乎每个字段都包装在Option中，然后对这些字段的每次访问都进行匹配的unwrap就会使代码变得很繁琐。

我们在上文的代码例基础上进行修改：

步骤1：改掉File的定义

为每一个字段添加一层Option<T>：

rust">/// 一个表示文件句柄的类型  
struct File {  /// 文件名  name: Option<String>,  /// 文件描述符  fd: Option<i32>,  
}

步骤2：修改File上的方法

File上有两个方法，我们都需要添加通过Option<T>这层壳来获取内部类型上字段的代码。

首先是open方法：

rust">/// 一个构造函数，打开一个文件并返回一个 File 实例  
fn open(name: &str) -> Result<File, Error> {  // 使用 OpenOptions 打开文件，具备读写权限  let file: StdFile = OpenOptions::new()  .read(true)  .write(true)  .open(name)?;  // 获取文件描述符  let fd: i32 = file.as_raw_fd();  // 返回一个 File 实例  Ok(File {  name: Some(name.to_string()),  fd: Some(fd),  })  
}
  • open方法的参数没有涉及到File结构体，所以接收参数部分不用修改
  • open方法的返回值涉及到了File，得为每个字段添上Some变体

其次是close方法：

rust">/// 一个显式的析构函数，关闭文件并返回任何错误  
fn close(mut self) -> Result<(), Error> {  // 模式匹配，并使用std::mem::take取出name字段的值  if let Some(name) = std::mem::take(&mut self.name) {  //模式匹配，并使用std::mem::take取出fd字段的值  if let Some(fd) = std::mem::take(&mut self.fd) {// 打印println!("Closing file: {} with fd: {}", name, fd);// 使用 FromRawFd 将 fd 转换回 File            let file: std::fs::File = unsafe {  std::os::unix::io::FromRawFd::from_raw_fd(fd)  };  // 刷新文件数据到磁盘  file.sync_all()?;  // 将文件截断为 0 字节  file.set_len(0)?;  // 再次刷新文件  file.sync_all()?;  // 丢弃文件实例，它会自动关闭文件  drop(file);  // 返回成功  Ok(())  } else {  // 如果fd字段是None，说明文件已经被关闭或丢弃，返回一个错误  Err(Error::new(  std::io::ErrorKind::Other,  "File descriptor already dropped or taken",  ))  }  } else {  // 如果name字段是None，说明文件已经被关闭或丢弃，返回一个错误  Err(Error::new(  std::io::ErrorKind::Other,  "File name already dropped or taken",  ))  }  
}
  • 参数要先经过模式匹配，并使用std::mem::take取出里面的值
  • 如果任意字段是None，说明文件已经被关闭或丢弃，返回一个错误

步骤3：修改Drop trait的实现

rust">fn drop(&mut self) {  // 使用模式匹配获取字段值  if let Some(name) = self.name.take() {  if let Some(fd) = self.fd.take() {  println!("Dropping file: {} (fd: {})", name, fd);  // 使用 FromRawFd 将 fd 转换回 Filelet file: std::fs::File = unsafe {  std::os::unix::io::FromRawFd::from_raw_fd(fd)  };  // 丢弃file实例    drop(file);  } else {  // 如果fd字段是None，说明文件已经被关闭或丢弃，不做任何操作  }  } else {  // 如果name字段是None，说明文件已经被关闭或丢弃，不做任何操作  }  
}
  • 参数要先经过模式匹配，并使用std::mem::take取出里面的值
  • 如果任意字段是None，说明文件已经被关闭或丢弃，不做任何操作

步骤4：微修主函数

rust">fn main() {// ...前文无修改，已省略// 打印文件名和 fd (这里需要修改)  println!("File name: {}, fd: {}",   file.name.as_ref().unwrap(),  file.fd.as_ref().unwrap()  );// ...后文无修改，已省略
}
  • 原始类型被Option<T>包裹，调用.as_ref()后获得里面值的引用
  • 变成了引用之后再使用unwrap提取出来的值就是引用而不是所有的值
  • 而直接访问Option的值需要转移所有权或匹配处理（例如通过 take() 或 unwrap()），这会销毁Option的内部值，所以得要as_ref

整体代码

rust">use std::os::fd::AsRawFd;  
use std::fs::{File as StdFile, OpenOptions, metadata};  
use std::io::Error;  /// 一个表示文件句柄的类型  
struct File {  /// 文件名  name: Option<String>,  /// 文件描述符  fd: Option<i32>,  
}  impl File {  /// 一个构造函数，打开一个文件并返回一个 File 实例  fn open(name: &str) -> Result<File, Error> {  // 使用 OpenOptions 打开文件，具备读写权限  let file: StdFile = OpenOptions::new()  .read(true)  .write(true)  .open(name)?;  // 获取文件描述符  let fd: i32 = file.as_raw_fd();  // 返回一个 File 实例  Ok(File {  name: Some(name.to_string()),  fd: Some(fd),  })  }  /// 一个显式的析构函数，关闭文件并返回任何错误  fn close(mut self) -> Result<(), Error> {  // 模式匹配，并使用使用std::mem::take取出name字段的值  if let Some(name) = std::mem::take(&mut self.name) {  //模式匹配，并使用使用std::mem::take取出fd字段的值  if let Some(fd) = std::mem::take(&mut self.fd) {// 打印println!("Closing file: {} with fd: {}", name, fd);// 使用 FromRawFd 将 fd 转换回 File                let file: std::fs::File = unsafe {  std::os::unix::io::FromRawFd::from_raw_fd(fd)  };  // 刷新文件数据到磁盘  file.sync_all()?;  // 将文件截断为 0 字节  file.set_len(0)?;  // 再次刷新文件  file.sync_all()?;  // 丢弃文件实例，它会自动关闭文件  drop(file);  // 返回成功  Ok(())  } else {  // 如果fd字段是None，说明文件已经被关闭或丢弃，返回一个错误  Err(Error::new(  std::io::ErrorKind::Other,  "File descriptor already dropped or taken",  ))  }  } else {  // 如果name字段是None，说明文件已经被关闭或丢弃，返回一个错误  Err(Error::new(  std::io::ErrorKind::Other,  "File name already dropped or taken",  ))  }  }  
}  // 实现drop trait，用于在值离开作用域时运行的一些代码  
impl Drop for File {  fn drop(&mut self) {  // 使用模式匹配获取字段值  if let Some(name) = self.name.take() {  if let Some(fd) = self.fd.take() {  println!("Dropping file: {} (fd: {})", name, fd);  // 使用 FromRawFd 将 fd 转换回 Filelet file: std::fs::File = unsafe {  std::os::unix::io::FromRawFd::from_raw_fd(fd)  };  // 丢弃file实例    drop(file);  } else {  // 如果fd字段是None，说明文件已经被关闭或丢弃，不做任何操作  }  } else {  // 如果name字段是None，说明文件已经被关闭或丢弃，不做任何操作  }  }  
}  fn main() {  // 创建一个名为 "test.txt" 的文件，并写入一些内容  std::fs::write("test.txt", "Hello, world!").unwrap();  // 打开文件并获取 File 实例  let file: File = File::open("test.txt").unwrap();  // 打印文件名和 fd (这里需要修改)   println!("File name: {}, fd: {}",   file.name.as_ref().unwrap(),  file.fd.as_ref().unwrap()  );  // 关闭文件并处理任何错误  match file.close() {  Ok(()) => println!("File closed successfully"),  Err(e) => println!("Error closing file: {}", e),  }  // 检查关闭后的文件大小  let metadata = metadata("test.txt").unwrap();  println!("File size: {} bytes", metadata.len());  
}

方法3：将数据持有在ManuallyDrop类型内

将数据持有在ManuallyDrop类型内，它会解引用内部类型，不必再使用unwrap。

在drop中进行销毁时，可使用ManuallyDrop::take来获取所有权。

缺点：ManuallyDrop::take是不安全的，需要放在unsafe块中。

我们在上文的代码例基础上进行修改：

步骤1：改掉File的定义

为每一个字段添加一层Option<T>：

rust">/// 一个表示文件句柄的类型  
struct File {  /// 文件名  name: ManuallyDrop<String>,  /// 文件描述符  fd: ManuallyDrop<i32>,  
}

步骤2：修改File上的方法

File上有两个方法，我们都需要添加通过Option<T>这层壳来获取内部类型上字段的代码。

首先是open方法：

rust">/// 一个构造函数，打开一个文件并返回一个 File 实例  
fn open(name: &str) -> Result<File, Error> {  // 使用 OpenOptions 打开文件，具备读写权限  let file: StdFile = OpenOptions::new()  .read(true)  .write(true)  .open(name)?;  // 获取文件描述符  let fd: i32 = file.as_raw_fd();  // 返回一个 File 实例  Ok(File {  name: ManuallyDrop::new(name.to_string()),  fd: ManuallyDrop::new(fd),  })  
}
  • open方法的参数没有涉及到File结构体，所以接收参数部分不用修改
  • open方法的返回值涉及到了File，每个字段都得用ManuallyDrop::new来传值

其次是close方法：

rust">/// 一个显式的析构函数，关闭文件并返回任何错误  
fn close(mut self) -> Result<(), Error> {  // 使用std::mem::replace将name字段替换为一个空字符串，把原来的值给name  let name =   std::mem::replace(&mut self.name, ManuallyDrop::new("".to_string()));  // 使用std::mem::replace将fd字段替换为一个无效的值(-1)，把原来的值给fd let fd =   std::mem::replace(&mut self.fd, ManuallyDrop::new(0));  // 打印  println!("Closing file: {:?} with fd: {:?}", name, fd);  // 使用 FromRawFd 将 fd 转换回 File    let file: std::fs::File = unsafe {  std::os::unix::io::FromRawFd::from_raw_fd(*fd) //这里fd要先解引用  };  // 刷新文件数据到磁盘  file.sync_all()?;  // 将文件截断为 0 字节  file.set_len(0)?;  // 再次刷新文件  file.sync_all()?;  // 丢弃文件实例，它会自动关闭文件  drop(file);  // 返回成功  Ok(())  
}
  • 使用std::mem::replace将name字段替换为一个空字符串，把原来的值给name
  • 使用std::mem::replace将fd字段替换为一个无效的值(-1)，把原来的值给fd
  • std::os::unix::io::FromRawFd::from_raw_fd(*fd)中参数要先解引用，也就是写*fd

步骤3：修改Drop trait的实现

rust">fn drop(&mut self) {  // 使用ManuallyDrop::take取出name字段的值，并检查是否是空字符串  let name = unsafe { ManuallyDrop::take(&mut self.name) };  // 使用ManuallyDrop::take取出fd字段的值，并检查是否是无效的值  let fd = unsafe { ManuallyDrop::take(&mut self.fd) };  //打印  println!("Dropping file: {:?} (fd: {:?})", name, fd);  // 如果fd字段不是无效的值，说明文件还没有被关闭或丢弃，需要执行丢弃操作  if fd != -1 || !name.is_empty() {  let file = unsafe { std::fs::File::from_raw_fd(fd) };  // 丢弃  drop(file);  }
}
  • 使用ManuallyDrop::take取出name和fd字段的值，并检查是否是空字符串或无效的值
  • 如果fd字段不是无效的值(不是-1)，或是name字段不是空字符串，就说明文件还没有被关闭或丢弃，需要执行丢弃操作
  • 其实这里不用两个判断条件(fd != -1 || !name.is_empty())，一个就够了，因为name和fd字段的值的变化是一起的，一个无效就代表着整个结构体都还未被清理。

步骤4：微修主函数

rust">fn main() {// ...前文无修改，已省略// 打印文件名和 fd (这里需要修改)  println!("File name: {}, fd: {}", *file.name, *file.fd);// ...后文无修改，已省略
}
  • 使用解引用来打印值

整体代码

rust">use std::os::fd::{AsRawFd, FromRawFd};  
use std::fs::{File as StdFile, OpenOptions, metadata};  
use std::io::Error;  
use std::mem::ManuallyDrop;  /// 一个表示文件句柄的类型  
struct File {  /// 文件名  name: ManuallyDrop<String>,  /// 文件描述符  fd: ManuallyDrop<i32>,  
}  impl File {  /// 一个构造函数，打开一个文件并返回一个 File 实例  fn open(name: &str) -> Result<File, Error> {  // 使用 OpenOptions 打开文件，具备读写权限  let file: StdFile = OpenOptions::new()  .read(true)  .write(true)  .open(name)?;  // 获取文件描述符  let fd: i32 = file.as_raw_fd();  // 返回一个 File 实例  Ok(File {  name: ManuallyDrop::new(name.to_string()),  fd: ManuallyDrop::new(fd),  })  }  /// 一个显式的析构函数，关闭文件并返回任何错误  fn close(mut self) -> Result<(), Error> {  // 使用std::mem::replace将name字段替换为一个空字符串，把原来的值给name  let name =   std::mem::replace(&mut self.name, ManuallyDrop::new("".to_string()));  // 使用std::mem::replace将fd字段替换为一个无效的值(-1)，把原来的值给fd  let fd =   std::mem::replace(&mut self.fd, ManuallyDrop::new(-1));  // 打印  println!("Closing file: {:?} with fd: {:?}", name, fd);  // 使用 FromRawFd 将 fd 转换回 File        let file: std::fs::File = unsafe {  std::os::unix::io::FromRawFd::from_raw_fd(*fd) //这里fd要先解引用  };  // 刷新文件数据到磁盘  file.sync_all()?;  // 将文件截断为 0 字节  file.set_len(0)?;  // 再次刷新文件  file.sync_all()?;  // 丢弃文件实例，它会自动关闭文件  drop(file);  // 返回成功  Ok(())  }  
}  // 实现drop trait，用于在值离开作用域时运行的一些代码  
impl Drop for File {  fn drop(&mut self) {  // 使用ManuallyDrop::take取出name字段的值，并检查是否是空字符串  let name = unsafe { ManuallyDrop::take(&mut self.name) };  // 使用ManuallyDrop::take取出fd字段的值，并检查是否是无效的值  let fd = unsafe { ManuallyDrop::take(&mut self.fd) };  //打印  println!("Dropping file: {:?} (fd: {:?})", name, fd);  // 如果fd字段不是无效的值，说明文件还没有被关闭或丢弃，需要执行丢弃操作  if fd != -1 || !name.is_empty() {  let file = unsafe { std::fs::File::from_raw_fd(fd) };  // 丢弃  drop(file);  }  }  
}  fn main() {  // 创建一个名为 "test.txt" 的文件，并写入一些内容  std::fs::write("test.txt", "Hello, world!").unwrap();  // 打开文件并获取 File 实例  let file: File = File::open("test.txt").unwrap();  // 打印文件名和 fd (这里需要修改)   
println!("File name: {}, fd: {}", *file.name, *file.fd);  // 关闭文件并处理任何错误  match file.close() {  Ok(()) => println!("File closed successfully"),  Err(e) => println!("Error closing file: {}", e),  }  // 检查关闭后的文件大小  let metadata = metadata("test.txt").unwrap();  println!("File size: {} bytes", metadata.len());  
}

三种方案的选择

这三种方案的选择要根据实际情况，通常第二个方案。但是如果真的字段太多要写的unwrap太多的话就需要考虑其他的方案。

如果代码足够简单，可以轻松检查代码的安全性，那么第三种ManuallyDrop方案也是非常好的。


http://www.ppmy.cn/devtools/162862.html

相关文章

社群团购平台的愿景构建与开源链动2+1模式S2B2C商城小程序应用探索

社群团购平台的愿景构建与开源链动2+1模式S2B2C商城小程序应用探索

摘要&#xff1a;在数字经济背景下&#xff0c;社群团购作为一种新兴的商业模式&#xff0c;凭借其独特的互动性和便捷性&#xff0c;展现出巨大的市场潜力。本文旨在探讨社群团购平台愿景的构建策略&#xff0c;并结合开源链动21模式S2B2C商城小程序的应用&#xff0c;为创业者…
阅读更多...
【linux配置】 修改内核网络参数

【linux配置】 修改内核网络参数

命令解释 echo 1 > /proc/sys/net/ipv4/conf/all/arp_ignore 这个命令的具体含义是&#xff1a; echo 1&#xff1a;将值1写入文件。 /proc/sys/net/ipv4/conf/all/arp_ignore&#xff1a;将值1写入 /proc/sys/net/ipv4/conf/all/arp_ignore 文件&#xff0c;从而修改内核参…
阅读更多...
Nginx的安装和部署以及Nginx的反向代理与负载均衡

Nginx的安装和部署以及Nginx的反向代理与负载均衡

Nginx的安装和部署以及Nginx的反向代理与负载均衡 1. 本文内容 Nginx的安装Nginx的静态网站部署Nginx的反向代理与负载均衡&#xff0c;配置反向代理与负载均衡 2. Nginx的安装与启动 2.1 什么是Nginx Nginx是一款高性能的http服务器/反向代理服务器及电子邮件&#xff08…
阅读更多...
机器学习基础入门——机器学习库介绍（NumPy、pandas、Matplotlib）

机器学习基础入门——机器学习库介绍（NumPy、pandas、Matplotlib）

机器学习库介绍&#xff08;NumPy、pandas、Matplotlib&#xff09; 在 Python 机器学习的领域中&#xff0c;NumPy、pandas 和 Matplotlib 是三个不可或缺的基础库。它们分别在数值计算、数据处理与分析以及数据可视化方面发挥着关键作用&#xff0c;极大地提升了开发效率与数…
阅读更多...
《Operating System Concepts》阅读笔记：p125-p146

《Operating System Concepts》阅读笔记：p125-p146

《Operating System Concepts》学习第 14 天&#xff0c;p125-p146 总结&#xff0c;总计 20 页。 一、技术总结 1.IPC(Interprocesses Comunicating) (1) shared memory (2)message passing 2.primitive (1)语言中的 primitive primitive: primus(“first”, 参考 prim…
阅读更多...
xxl-job 源码解析，分布式任务调度xxl-job 客户端启动 执行器原理（二）

xxl-job 源码解析，分布式任务调度xxl-job 客户端启动 执行器原理（二）

当前主要介绍了&#xff1a;执行器如何进行初始化&#xff0c;如何向调度器注册&#xff0c;调度器侧接收相关方法分析 目录&#xff1a; 1. 配置xxl-job数据库环境&#xff0c;将调度器&#xff0c;执行器demo进行启动。 2. 分析执行器启动流程 3. 分析调度器接收心跳流程 1…
阅读更多...
将VsCode变得顺手好用（1

将VsCode变得顺手好用（1

目录 设置中文 配置调试功能 提效和增强相关插件 主题和图标相关插件 设置中文 打开【拓展】 输入【Chinese】 下载完成后重启Vs即可变为中文 配置调试功能 在随便一个位置新建一个文件夹&#xff0c;用于放置调试文件以及你未来写的代码&#xff0c;随便命名但切记不可用中…
阅读更多...
4. MySQL 逻辑架构说明

4. MySQL 逻辑架构说明

4. MySQL 逻辑架构说明 文章目录 4. MySQL 逻辑架构说明1. 逻辑架构剖析1.1 服务器处理客户端请求1.2 Connectors(连接器)1.3 第1层&#xff1a;连接层1.4 第2层&#xff1a;服务层1.5 第3层&#xff1a;引擎层1.6 存储层 2. SQL执行流程2.1 MySQL 中的 SQL 执行流程 2.2 MySQL…
阅读更多...
最新文章

Copyright @ 2022~2023