Rust 中的静态结构

Question

我正在使用 Nickel.rs 构建一个待办事项列表示例。由于暂时不支持闭包，我正在尝试寻找另一种方法来处理我实现的简单结构。

这是我的代码：

extern crate nickel;

use std::io::net::ip::Ipv4Addr;
use nickel::{Nickel, Request, Response};

struct TaskList {
    list: Vec<String>
}

impl TaskList {
    fn new() -> TaskList {
        TaskList { list: Vec::new() }
    }

    fn add_task (&mut self, task: &str) {
        &self.list.push(task.to_string());
    }

    fn get_tasks (&self) -> Vec<String> {
        self.list.to_vec()
    }
}

fn main() {
    let mut server = Nickel::new();

    static mut sample : TaskList = TaskList { list: Vec::new() };

    sample.add_task("First");
    sample.add_task("Second");

    fn fetch_tasks (_request: &Request, response: &mut Response) {
        response.send(sample.get_tasks().to_string())
    }

    server.utilize(Nickel::static_files("./public"));

    server.get("/task", fetch_tasks);
    server.listen(Ipv4Addr(127, 0, 0, 1), 6767);
}

但是编译器给我写了这个：“可变静态项不允许有析构函数”

你对我如何解决这个问题有什么建议吗？

Answer 1

我不太确定你想要达到什么目的。

如果您希望 TaskList 存在于堆上，请使用 Box。但是，堆栈范围应该是 server.listen() 中的有效事件，所以我不明白为什么您需要 TaskList 成为静态 mut？

如果你想搞乱静态变量，你必须这样做不安全，像这样：

use std::mem::transmute;
use std::ptr;

struct Static {
  v: int
}

impl Static {
  fn whatever(&mut self) {
    println!("Write to static");
    self.v += 1;
  }
}

static mut _data:*const Static = 0 as *const Static;

unsafe fn get<'a>() -> &'a mut Static {
  if _data == ptr::null::<Static>() {

    // Notice this is a Box<Static>, which is a *Static allocated on the heap
    // transmute(Static { v: 0 }) wouldn't work because once the stack scope ends
    // the instance would no longer be valid; Box<T> lasts beyond the call to get()
    _data = transmute(box Static { v: 0 });
  }
  return transmute(_data);
}

unsafe fn release() {
  ptr::read::<Static>(_data);
}

impl Drop for Static {
  fn drop(&mut self) {
    println!("Dropped static");
  }
}

fn main() {
  unsafe {
    let foo = get();
    foo.whatever();
  }
  unsafe {
    let foo = get();
    foo.whatever();
  }
  unsafe {
    release();
  }
  println!("Done");
}

我强烈建议不要这样做，除非有很好的理由。

大多数时候你可以假设你在一个范围内创建的变量：

{
   let foo = Bar; 
   ...
} <-- End

将继续有效，直到该范围结束。

像 server.get 这样的子调用仍在定义 sample 的 main() { } 范围内。

它仍然有效。