मैं बिना किसी असाइनमेंट के स्थिर स्थिर परिवर्तनीय घोषित कैसे करूं?

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 आइटम, हो सकता है, और वहाँ कोई अंतर-रखने आइटम (विशेषता और प्रकार परिभाषाएं, कार्य, & सी।) के अंदर एक समारोह विशुद्ध रूप से उन्हें छुपाता है बाहरी दायरे से। इसलिए आप आमतौर पर 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:

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

---

:

#[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); 
} 

---

वैकल्पिक रूप से, बस अपनी स्वयं आलसी एक्सेसर बनाने

कहने की जरूरत नहीं है, यह कोड थ्रेड-सुरक्षित नहीं है और इस प्रकार जंग की सुरक्षा गारंटीओं में से कुछ को बंद कर देता है, लेकिन गति तुलना पोर्ट के लिए यह पर्याप्त होगा।