जंग

Question

में दो आयामी सरणी बनाना, मैं जंग में एक खाली म्यूटेबल दो आयामी सरणी कैसे बना सकता हूं?

यह वही है मैं अब तक की कोशिश की है है:

let mut state[[u8 * 4] * 4]; 

यह त्रुटि पैदा करता

error: expected one of `:`, `;`, `=`, or `@`, found `[` 
--> src/main.rs:2:18 
    | 
2 |  let mut state[[u8 * 4] * 4]; 
    |    ^expected one of `:`, `;`, `=`, or `@` here 

Answer 1

संपादक की टिप्पणी: इस जवाब से पहले जंग 1.0 और अवधारणाओं और वाक्य रचना के कुछ बदल गया है । अन्य उत्तर जंग 1.0 पर लागू होते हैं।

आप सरणी की सामग्री परिवर्तनशील या चर हैं कि उनके पास होने के लिए करना चाहते हैं? यदि आप उत्परिवर्तनीय सामग्री चाहते हैं, तो यह आपके लिए काम करता है?

let state = [mut [mut 0u8, ..4], ..4]; 

आप चर परिवर्तनशील होना चाहते हैं, लेकिन उनकी सामग्री नहीं, तो इस कोशिश:

let mut state = [[0u8, ..4], ..4]; 

इस मदद करता है? मैंने वास्तव में इसे संकलित नहीं किया था, इसलिए वाक्यविन्यास थोड़ा सा हो सकता है।

Answer 2

जंग 1.0 में, निम्न काम करता है:

let mut state = [[0u8; 4]; 6]; 
state[0][1] = 42; 

ध्यान दें कि आंतरिक खंड की लंबाई प्रकार का एक अभिन्न हिस्सा है।

let a: &[[u8; 4]] = &state; 

नहीं बल्कि उप सरणी के निर्धारित लंबाई निर्दिष्ट किए बिना: उदाहरण के लिए, आप के रूप में निम्नानुसार संदर्भित कर सकते हैं (और पारित) state। आप इस तरह से कुछ करने के लिए आवश्यकता हो सकती है कि आप चर लंबाई उप सरणियों की जरूरत है:

let x: [Box<[u8]>; 3] = [ 
    Box::new([1, 2, 3]), 
    Box::new([4]), 
    Box::new([5, 6]) 
]; 
let y: &[Box<[u8]>] = &x; 

Answer 3

आप इस प्रकार का गतिशील रूप से आकार 2 डी वेक्टर बना सकते हैं:

fn example(width: usize, height: usize) { 
    // Base 1d array 
    let mut grid_raw = vec![0; width * height]; 

    // Vector of 'width' elements slices 
    let mut grid_base: Vec<_> = grid_raw.as_mut_slice().chunks_mut(width).collect(); 

    // Final 2d array 
    let grid: &mut [&mut [_]] = grid_base.as_mut_slice(); 

    // Accessing data 
    grid[0][0] = 4; 
} 

Answer 4

मुहावरेदार सी 2-आयामी सरणी हैं के रूप में जब सरणी तक पहुँचने के लिए इस्तेमाल किया सरणी आकार के एक ही आदेश का उपयोग कर की घोषणा की:

// Declaration 
int array_2d[8][16]; // An 8 by 16 2D array 
... 
// Access 
array_2d[0][1] = 5; 

जंग में, घोषणा आकार फ़्लिप कर रहे हैं; 8 से 16 2-आयामी सरणी बनाने के लिए, वाक्यविन्यास है:

// Declaration 
let mut array_2d: [[i32; 16]; 8]; 
... 
// Access (same as idiomatic C. types for added explicitness) 
array_2d[0_usize][1_usize] = 5;