Rust
कच्चे पॉइंटर्स

वाक्य - विन्यास

• चलिए कच्चे_प्रात = और संकेत के रूप में * कॉन्स्ट प्रकार // कुछ डेटा के लिए निरंतर कच्चे सूचक बनाते हैं
• कच्चे_mut_ptr = और उत्परिवर्ती सूचक को * mut प्रकार के रूप में दें। कुछ उत्परिवर्तनीय डेटा के लिए उत्परिवर्तित कच्चे सूचक बनाएं
• deref = * raw_ptr // dereference a रॉ पॉइंटर (असुरक्षित ब्लॉक की आवश्यकता है)

टिप्पणियों

लगातार कच्चे पॉइंटर्स बनाना और उनका उपयोग करना

// Let's take an arbitrary piece of data, a 4-byte integer in this case
let some_data: u32 = 14;

// Create a constant raw pointer pointing to the data above
let data_ptr: *const u32 = &some_data as *const u32;

// Note: creating a raw pointer is totally safe but dereferencing a raw pointer requires an
// unsafe block
unsafe {
    let deref_data: u32 = *data_ptr;
    println!("Dereferenced data: {}", deref_data);
}

उपरोक्त कोड आउटपुट होगा: Dereferenced data: 14

उत्परिवर्तित कच्चे पॉइंटर्स बनाना और उनका उपयोग करना

// Let's take a mutable piece of data, a 4-byte integer in this case
let mut some_data: u32 = 14;

// Create a mutable raw pointer pointing to the data above
let data_ptr: *mut u32 = &mut some_data as *mut u32;

// Note: creating a raw pointer is totally safe but dereferencing a raw pointer requires an
// unsafe block
unsafe {
    *data_ptr = 20;
    println!("Dereferenced data: {}", some_data);
}

उपरोक्त कोड आउटपुट होगा: Dereferenced data: 20

एक कच्चे सूचक को शून्य करने के लिए प्रारंभ करना

सामान्य जंग के संदर्भों के विपरीत, कच्चे पॉइंटर्स को शून्य मान लेने की अनुमति है।

use std::ptr;

// Create a const NULL pointer
let null_ptr: *const u16 = ptr::null();

// Create a mutable NULL pointer
let mut_null_ptr: *mut u16 = ptr::null_mut();

चेन-dereferencing

सी की तरह ही, रस्ट रॉ पॉइंटर्स अन्य रॉ पॉइंटर्स को इंगित कर सकते हैं (जो बदले में आगे के रॉ पॉइंटर्स को इंगित कर सकते हैं)।

// Take a regular string slice
let planet: &str = "Earth";

// Create a constant pointer pointing to our string slice
let planet_ptr: *const &str = &planet as *const &str;

// Create a constant pointer pointing to the pointer
let planet_ptr_ptr: *const *const &str = &planet_ptr as *const *const &str;

// This can go on...
let planet_ptr_ptr_ptr = &planet_ptr_ptr as *const *const *const &str;

unsafe {
    // Direct usage
    println!("The name of our planet is: {}", planet);
    // Single dereference
    println!("The name of our planet is: {}", *planet_ptr);
    // Double dereference
    println!("The name of our planet is: {}", **planet_ptr_ptr);
    // Triple dereference
    println!("The name of our planet is: {}", ***planet_ptr_ptr_ptr);
}

यह आउटपुट देगा: The name of our planet is: Earth चार बार।

कच्चे संकेत प्रदर्शित करना

रस्ट में पॉइंटर प्रकारों के लिए एक डिफ़ॉल्ट फॉर्मैटर होता है जिसका उपयोग पॉइंटर्स को प्रदर्शित करने के लिए किया जा सकता है।

use std::ptr;

// Create some data, a raw pointer pointing to it and a null pointer
let data: u32 = 42;
let raw_ptr = &data as *const u32;
let null_ptr = ptr::null() as *const u32;

// the {:p} mapping shows pointer values as hexadecimal memory addresses
println!("Data address: {:p}", &data);
println!("Raw pointer address: {:p}", raw_ptr); 
println!("Null pointer address: {:p}", null_ptr);

यह कुछ इस तरह से उत्पादन करेगा:

Data address: 0x7fff59f6bcc0
Raw pointer address: 0x7fff59f6bcc0
Null pointer address: 0x0