Question

我尝试了以下

struct mbuf
{
  cacheline: *mut [u64],               // great amount of rows follows below
  // ..........
}
static mut arr: [mbuf; 32];                // Q1 my main aim
// something as before but using Vec;      // Q2 also main aim

fn main() {
 // let static mut arr: [mbuf; 32];        // Q3 also doesn't work
 // static mut arr: [mbuf; 32];            // Q3 also doesn't work
}

并收到错误

src/main.rs:74:29: 74:30 error: expected one of `+` or `=`, found `;`
src/main.rs:74   static mut arr: [mbuf; 32];
                                           ^

Q1，Q2，Q3 - 是否可能以及如何？

Answer 1

声明时必须分配静态或常量;在此之后，他们永远不会被分配。

静态必须纯粹是文字;它不能有任何函数调用。

目前，常数必须是纯粹的文字，但是当实施RFC 911, const fn时，可以更像你想要的事情。

在函数内部，您可以拥有static或const个项目，就像在函数外部一样，并且没有差异 - 放置项目（特征和类型定义，函数，＆amp; c。）函数内部纯粹将它们从外部范围隐藏起来。因此，您通常也可以使用let foo。

Answer 2

您可以使用lazy-static在第一次访问时初始化静态数组，即使它可能产生最小的开销（每次访问静态变量时它似乎都会调用Once::call_once）。

例如，Cargo.toml：

[package]
name = "arr"
version = "0.0.1"

[[bin]]
name = "arr"
path = "arr.rs"

[dependencies]
lazy_static = "*"

arr.rs：

#[macro_use]
extern crate lazy_static;
use std::mem;
use std::ptr;

#[derive(Debug)]
struct Mbuf {
    cacheline: *mut u64,
}
// Let's pretend it's thread-safe to appease the lazy_static! constrains.
unsafe impl Sync for Mbuf { }

lazy_static! {
    static ref ARR: [Mbuf; 32] = {
        let mut tmp: [Mbuf; 32] = unsafe { mem::uninitialized() };
        for idx in 0..tmp.len() {
            tmp[idx] = Mbuf { cacheline: ptr::null_mut() };
        }
        tmp
    };
}

fn main() {
    println!("{:?}", *ARR);
}

或者，只需创建自己的懒惰访问者：

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

#[derive(Debug)]
struct Mbuf {
    cacheline: *mut u64,
}

static mut ARR: Option<[Mbuf; 32]> = None;
fn arr() -> &'static mut [Mbuf; 32] {
    unsafe {
        if ARR.is_none() {
            let mut tmp: [Mbuf; 32] = mem::uninitialized();
            for idx in 0..tmp.len() {
                tmp[idx] = Mbuf { cacheline: ptr::null_mut() };
            }
            ARR = Some(tmp);
        }
        mem::transmute(ARR.as_mut().unwrap())
    }
}

fn main() {
    println!("{:?}", arr());
}

毋庸置疑，这段代码不是线程安全的，因此避免了一些Rust安全保证，但对于速度比较端口来说就足够了。

如何在没有赋值的情况下声明静态可变变量？

2 个答案: