Unsafe Dereferencing and Raw Pointers in Rust

Rust's memory safety guarantees are a cornerstone of its design. However, there are scenarios where direct memory manipulation is necessary, such as interacting with C libraries, implementing low-level data structures, or optimizing performance-critical code. This challenge will guide you through the creation and usage of unsafe Rust code to perform direct memory access using raw pointers.

Problem Description

Your task is to create a Rust program that demonstrates the use of unsafe blocks to perform memory operations that are not inherently safe. Specifically, you will:

1. Create a mutable raw pointer to a piece of data.
2. Dereference this raw pointer within an unsafe block to read its value.
3. Dereference this raw pointer within another unsafe block to modify its value.
4. Demonstrate the potential dangers by attempting a common unsafe operation.

This challenge will help you understand the boundaries of Rust's safety guarantees and the responsibilities that come with unsafe code.

Key Requirements

• You must use the unsafe keyword to perform the required memory operations.
• You must work with raw pointers (*mut T and *const T).
• You should create a variable, obtain a mutable raw pointer to it, read from it, write to it, and then print the original variable's value to show the change.
• Your code should compile and run without panicking in the "safe" execution path.

Examples

Example 1:

fn main() {
    let mut my_number = 42;
    println!("Initial value: {}", my_number);

    // --- Your unsafe code here ---
    // 1. Get a mutable raw pointer
    // 2. Dereference to read
    // 3. Dereference to write
    // 4. Print the original variable to show modification
    // --- End of your unsafe code ---

    println!("Final value: {}", my_number);
}

Expected Output:

Initial value: 42
Final value: 100

Explanation: The program starts with my_number as 42. The unsafe block will be used to create a raw pointer, change the value through this pointer to 100, and then the final print statement will show that my_number has indeed been updated to 100.

Example 2: Illustrating a potential issue (for demonstration, not to be made safe within the challenge itself)

fn main() {
    let mut data = vec![10, 20, 30];
    let ptr: *const i32 = data.as_ptr(); // Get a pointer to the first element

    unsafe {
        // Reading beyond the bounds of the allocated memory
        // THIS IS UNDEFINED BEHAVIOR AND SHOULD NOT BE DONE IN PRODUCTION CODE
        // but we'll print it here to show the concept.
        println!("Value at index 0: {}", *ptr);
        println!("Value at index 1: {}", *(ptr.add(1)));
        // Let's try to read past the end - this is dangerous!
        // println!("Potentially garbage data: {}", *(ptr.add(3))); // This might crash or show garbage
    }
}

Explanation: This example (for conceptual understanding) shows how you could read from memory using raw pointers. The challenge itself focuses on safe read/write within the bounds of a single variable. The ptr.add(n) method is used to offset the pointer. Reading past the end of allocated memory (ptr.add(3) in this case, as a vec of 3 elements would have indices 0, 1, 2) is undefined behavior. For this challenge, ensure you only dereference valid memory locations.

Constraints

• The primary variable you manipulate should be a primitive integer type (e.g., i32, u64).
• You must explicitly use the unsafe keyword.
• Do not use any external crates for this specific challenge.
• The code should compile with rustc without any warnings or errors related to memory safety in the "safe" parts of the code.
• The unsafe operations should only involve a single, valid memory location for reading and writing.

Notes

• unsafe in Rust means you are promising the compiler that you will uphold the memory safety guarantees for the operations within that block.
• Raw pointers (*mut T, *const T) do not have built-in guarantees like references do (e.g., they can be null, dangling, or point to uninitialized memory).
• Dereferencing a raw pointer is an unsafe operation because the compiler cannot verify its validity.
• The as_mut_ptr() or as_ptr() methods on mutable or immutable data can be used to obtain raw pointers.
• The *pointer syntax is used to dereference a raw pointer.
• Be very careful when working with raw pointers. Invalid operations can lead to segmentation faults, data corruption, or other hard-to-debug issues. This challenge is designed to introduce you to these concepts in a controlled environment.