Come si dichiara una variabile mutabile statica senza assegnazione?

Question

Ho provato il seguente

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 
} 

e ottenuto l'errore

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 - E 'possibile e come?

Answer 1

Una statica o una costante deve essere assegnata quando dichiarata; non potranno mai essere assegnati a quello dopo.

Una statica deve essere puramente letterale; non può avere chiamate di funzioni.

Una costante deve al momento essere puramente letterali, ma quando RFC 911, const fn è implementato sarà possibile fare le cose più come desideri.

all'interno di una funzione, è possibile avere static o const elementi, proprio come fuori da una funzione, e non c'è articoli differenza-ponendo (definizioni di tratto e tipo, funzioni, & c.) all'interno di una funzione puramente li nasconde dall'ambito esterno. Quindi in genere si potrebbe usare anche let foo.

Answer 2

È possibile utilizzare lazy-static per inizializzare l'array statico al primo accesso, anche se potrebbe comportare un sovraccarico minimo (sembra richiamare Once::call_once ogni volta che si accede alla variabile statica).

Per esempio, 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); 
} 

---

In alternativa, basta fare il vostro proprio di accesso pigro:

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()); 
} 

---

Inutile dire che questo codice non è thread-safe e quindi evita alcune delle garanzie di sicurezza di Rust, ma per una porta di confronto della velocità è sufficiente.