Rust
ऐरे, वैक्टर और स्लाइस

Arrays

एक सरणी एक एकल प्रकार की वस्तुओं की स्टैक-आवंटित, सांख्यिकीय रूप से आकार की सूची है।

वर्ग कोष्ठक के बीच आमतौर पर दिए गए प्रकार के तत्वों की एक सूची संलग्न करके सारणियां बनाई जाती हैं। एक सरणी का प्रकार विशेष वाक्यविन्यास के साथ दर्शाया गया है: [T; N] जहां T अपने तत्वों का प्रकार है और N उनकी गिनती है, दोनों को संकलन समय पर जाना जाना चाहिए।

उदाहरण के लिए, [4u64, 5, 6] का एक 3-तत्व सरणी है [u64; 3] । नोट: 5 और 6 टाइप u64 होने का अनुमान है।

उदाहरण

fn main() {
    // Arrays have a fixed size.
    // All elements are of the same type.
    let array = [1, 2, 3, 4, 5];

    // Create an array of 20 elements where all elements are the same.
    // The size should be a compile-time constant.
    let ones = [1; 20];

    // Get the length of an array.
    println!("Length of ones: {}", ones.len());

    // Access an element of an array.
    // Indexing starts at 0.
    println!("Second element of array: {}", array[1]);

    // Run-time bounds-check.
    // This panics with 'index out of bounds: the len is 5 but the index is 5'.
    println!("Non existant element of array: {}", array[5]);
}

सीमाएं

पैटर्न पर मिलान (या स्लाइस) स्थिर रस्ट में समर्थित नहीं है ( # 23121 और स्लाइस पैटर्न देखें )।

जंग प्रकार-स्तर के अंकों की उदारता का समर्थन नहीं करती है ( RFCs # 1657 देखें)। इसलिए, सभी सरणियों (सभी आकारों के) के लिए एक विशेषता को लागू करना संभव नहीं है। नतीजतन, मानक लक्षण केवल सीमित तत्वों तक की सरणियों के लिए लागू किए जाते हैं (अंतिम रूप से जाँच की गई, जिसमें 32 तक शामिल हैं)। अधिक तत्वों वाले एरे का समर्थन किया जाता है, लेकिन मानक लक्षण ( डॉक्स देखें) को लागू नहीं करते हैं।

उम्मीद है कि भविष्य में इन प्रतिबंधों को हटा लिया जाएगा।

वैक्टर

एक वेक्टर अनिवार्य रूप से एक प्रकार की वस्तुओं के ढेर-आवंटित, गतिशील रूप से आकार की सूची के लिए एक संकेतक है।

उदाहरण

fn main() {
    // Create a mutable empty vector
    let mut vector = Vec::new();

    vector.push(20);
    vector.insert(0, 10); // insert at the beginning

    println!("Second element of vector: {}", vector[1]); // 20

    // Create a vector using the `vec!` macro
    let till_five = vec![1, 2, 3, 4, 5];

    // Create a vector of 20 elements where all elements are the same.
    let ones = vec![1; 20];

    // Get the length of a vector.
    println!("Length of ones: {}", ones.len());

    // Run-time bounds-check.
    // This panics with 'index out of bounds: the len is 5 but the index is 5'.
    println!("Non existant element of array: {}", till_five[5]);
}

स्लाइस

स्लाइस वस्तुओं की एक सूची में विचार कर रहे हैं, और टाइप T साथ वस्तुओं के एक टुकड़ा का संकेत है, [T] ।

एक टुकड़ा एक अनसुलझा प्रकार है , और इसलिए इसका उपयोग केवल एक पॉइंटर के पीछे किया जा सकता है। (स्ट्रिंग विश्व सादृश्य: str , जिसे स्ट्रिंग स्लाइस कहा जाता है, भी अनसुलझा है।)

ऐरे को स्लाइस में ढाला जाता है, और वैक्टर को स्लाइस के रूप में चित्रित किया जा सकता है। इसलिए, स्लाइस विधियों को उन दोनों पर लागू किया जा सकता है। (स्ट्रिंग विश्व सादृश्य: str String , क्या है [T] Vec<T> ।)

fn main() {
    let vector = vec![1, 2, 3, 4, 5, 6, 7, 8];
    let slice = &vector[3..6];
    println!("length of slice: {}", slice.len()); // 3
    println!("slice: {:?}", slice); // [4, 5, 6]
}