Raw Pointers क्या हैं

Raw pointers memory में bare-bones addresses हैं जिन्हें Rust आपको उपयोग करने देता है, लेकिन सिर्फ unsafe के अंदर, क्योंकि वे usual safety checks skip करते हैं।

In this page:

Creating Raw Pointers
Mutable Raw Pointers
Raw Pointers Skip Borrow Checking
Why Raw Pointers Exist

Syntax

rust

let p = &value as *const Type;
let p = &mut value as *mut Type;
unsafe {
    let v = *p;
}

Creating Raw Pointers

Raw pointers as *const T या as *mut T उपयोग करके references से बनाए जा सकते हैं। खुद एक raw pointer बनाना पूरी तरह safe है -- सिर्फ इसे dereference करने के लिए unsafe चाहिए।

उदाहरण: Creating Raw Pointers

markup

// Entry point: execution of the program starts here
fn main() {
    // Declare an immutable variable `value`, set to `100`
    let value = 100;
    // Declare an immutable variable `const_ptr`, set to `&value as *const i32`
    let const_ptr = &value as *const i32;
    // Print "Pointer created (not yet dereferenced)" to the console (with a trailing newline)
    println!("Pointer created (not yet dereferenced)");
    unsafe {
        // Print "Value: {}" to the console, substituting in `*const_ptr` (with a trailing newline)
        println!("Value: {}", *const_ptr);
    }
}

Mutable Raw Pointers

*mut T pointer के ज़रिए pointed-to data modify करने देता है, लेकिन सभी raw pointer dereferences की तरह, ऐसा करने के लिए एक unsafe block चाहिए।

उदाहरण: Mutable Raw Pointers

markup

// Entry point: execution of the program starts here
fn main() {
    // Declare a mutable variable `value`, initialized to `5`
    let mut value = 5;
    // Declare an immutable variable `mut_ptr`, set to `&mut value as *mut i32`
    let mut_ptr = &mut value as *mut i32;
    unsafe {
        *mut_ptr += 1;
    }
    // Print "value = {}" to the console, substituting in `value` (with a trailing newline)
    println!("value = {}", value);
}

Raw Pointers Skip Borrow Checking

References के विपरीत, आपके पास उसी data के एक साथ कई raw pointers (यहां तक कि mutable वाले भी) हो सकते हैं, क्योंकि borrow checker raw pointers track नहीं करता -- यही बिल्कुल वजह है कि इन्हें dereference करना unsafe है।

उदाहरण: Raw Pointers Skip Borrow Checking

markup

// Entry point: execution of the program starts here
fn main() {
    // Declare a mutable variable `number`, initialized to `10`
    let mut number = 10;
    // Declare an immutable variable `p1`, set to `&mut number as *mut i32`
    let p1 = &mut number as *mut i32;
    // Declare an immutable variable `p2`, set to `&mut number as *mut i32`
    let p2 = &mut number as *mut i32;
    unsafe {
        *p1 += 1;
        *p2 += 1;
    }
    // Print "number = {}" to the console, substituting in `number` (with a trailing newline)
    println!("number = {}", number);
}

Why Raw Pointers Exist

Raw pointers foreign function interfaces (C code call करना) जैसे low-level tasks के लिए और internally safe abstractions बनाने के लिए ज़रूरी हैं, जहां implementer manually उन safety invariants की गारंटी देता है जिन्हें compiler जांच नहीं सकता।

उदाहरण: Why Raw Pointers Exist

markup

// Entry point: execution of the program starts here
fn main() {
    // Declare an immutable variable `array`, set to `[1, 2, 3, 4]`
    let array = [1, 2, 3, 4];
    // Declare an immutable variable `ptr`, set to `array.as_ptr()`
    let ptr = array.as_ptr();
    unsafe {
        // Print "First element via raw pointer: {}" to the console, substituting in `*ptr` (with a trailing newline)
        println!("First element via raw pointer: {}", *ptr);
        // Print "Second element via offset: {}" to the console, substituting in `*ptr.offset(1)` (with a trailing newline)
        println!("Second element via offset: {}", *ptr.offset(1));
    }
}

Chapter Quiz — Complete all 7 topics to unlock

0/7 topics done

Complete these topics first:

← Previous Lesson Unsafe Basics Next Lesson → Closure Traits: Fn, FnMut, FnOnce

Raw Pointers क्या हैं

Creating Raw Pointers

Mutable Raw Pointers

Raw Pointers Skip Borrow Checking

Why Raw Pointers Exist

Chapter Quiz — Complete all 7 topics to unlock

Login to run this code