Rust: ملكية Rust: المبادئ الأساسية الثلاثة لأمان الذاكرة

fn main() {
    let book = String::from("Rust Programming");  // book is the owner of this book
    // let book2 = book;                   // ❌ If you write it this way,book Ownership was transferred to book2
    // println!("{}", book);               // ❌ book Can no longer be used

    // ✅ The Correct Approach:Only one person can hold ownership at a time.
    println!("{} Belongs to Tom The Library", book);
}  // book Automatically destroyed here——No manual intervention required free

fn main() {
    // Data on the Stack:Fixed size,Copy Semantics
    let x: i32 = 5;        // Allocation on the Stack 4 Byte
    let y = x;              // Make a copy, x and y are both valid.
    println!("x={}, y={}", x, y);  // ✅ All are acceptable

    // Load the data:Varies in size,move Semantics
    let s1 = String::from("hello");  // s1 On the stack(ptr/len/cap),The actual data is on the heap.
    let s2 = s1;                     // ❌ Ownership from s1 Transfer to s2
    // println!("{}", s1);            // ❌ Compilation Error:s1 Has been moved
    println!("{}", s2);              // ✅ s2 It's the new owner.
}

// ============================================
// Demonstration of Ownership Transfer:Occurs during assignment move
// ============================================

fn main() {
    let s1 = String::from("Rust");
    let s2 = s1;  // s1 Ownership was transferred to s2

    // println!("s1: {}", s1);  // ❌ Compilation Error!s1 Has been moved
    println!("s2: {}", s2);     // ✅ s2 I am the owner now

    // Integer types are Copy, So it won't move
    let a = 42;
    let b = a;                 // a The value is copied to b
    println!("a: {}, b: {}", a, b);  // ✅ Both are effective.
}

s2: Rust
a: 42, b: 42

// ============================================
// Transfer of Ownership in Parameter Passing and Return Values
// ============================================

fn take_ownership(s: String) {
    println!("Acquire ownership: {}", s);
}  // s Destroyed here(drop)

fn give_ownership() -> String {
    let s = String::from("Newly created string");
    s  // Ownership is returned to the caller
}

fn main() {
    let s1 = String::from("hello");

    take_ownership(s1);  // s1 Ownership was transferred to the function
    // println!("{}", s1);  // ❌ s1 Expired

    let s2 = give_ownership();  // Acquiring Ownership from a Function
    println!("s2: {}", s2);     // ✅ s2 Ownership

    // Send it in and then send it back
    let s3 = String::from("Passing back and forth");
    let s3_back = takes_and_returns(s3);
    // println!("{}", s3);  // ❌ s3 Has been moved
    println!("s3_back: {}", s3_back);  // ✅
}

fn takes_and_returns(s: String) -> String {
    println!("Inside a function: {}", s);
    s  // Return ownership to the caller
}

Acquire ownership: hello
s2: Newly created string
Inside a function: Passing back and forth
s3_back: Passing back and forth

// ============================================
// Copy(Auto-Copy) vs Clone(Explicit Cloning)
// ============================================

fn main() {
    // --- Copy Type:Automatic Copy on Assignment ---
    let num1 = 100;
    let num2 = num1;         // Auto-Copy,num1 Still valid
    println!("Copy: num1={}, num2={}", num1, num2);  // ✅

    // --- Clone Type:Must be explicitly called .clone() ---
    let s1 = String::from("Cloning required");
    let s2 = s1.clone();     // Explicit Cloning,s1 Still valid
    println!("Clone: s1={}, s2={}", s1, s2);  // ✅

    // --- Neither Clone Nor Copy: only move ---
    let v1 = vec![1, 2, 3];
    let v2 = v1;  // move!v1 Failure
    // println!("{:?}", v1);  // ❌
    println!("v2: {:?}", v2);  // ✅
}

Copy: num1=100, num2=100
Clone: s1=Cloning required, s2=Cloning required
v2: [1, 2, 3]

// ============================================
// Common Patterns:Send it in and then send it back(Get+Return)
// ============================================

struct User {
    name: String,
    score: i32,
}

fn boost_score(mut user: User, bonus: i32) -> User {
    user.score += bonus;
    user
}

fn format_user(user: &User) -> String {
    format!("{}: {} pts", user.name, user.score)
}

fn main() {
    let alice = User {
        name: String::from("Alice"),
        score: 80,
    };

    println!("Before the upgrade: {}", format_user(&alice));

    let alice = boost_score(alice, 15);
    println!("After the upgrade: {}", format_user(&alice));

    let alice = boost_score(alice, 10);
    println!("Upgrade Again: {}", format_user(&alice));

    let mut bob = User {
        name: String::from("Bob"),
        score: 60,
    };

    let bonus = 20;
    bob.score += bonus;
    println!("Bob After the bonus points are added: {}", format_user(&bob));

    let names = vec![alice.name.clone(), bob.name.clone()];
    println!("All users: {:?}", names);

    println!("Alice Final Score: {}", alice.score);
    println!("Bob Final Score: {}", bob.score);
}

Before the upgrade: Alice: 80 pts
After the upgrade: Alice: 95 pts
Upgrade Again: Alice: 105 pts
Bob After the bonus points are added: Bob: 80 pts
All users: ["Alice", "Bob"]
Alice Final Score: 105
Bob Final Score: 80

// ============================================
// Vec,String Common Interaction Patterns with Ownership
// ============================================

fn take_first_word(words: &Vec<String>) -> Option<&str> {
    words.first().map(|s| s.as_str())
}

fn remove_and_return(vec: &mut Vec<i32>, index: usize) -> Option<i32> {
    if index < vec.len() {
        Some(vec.remove(index))
    } else {
        None
    }
}

fn main() {
    let mut words = vec![
        String::from("hello"),
        String::from("rust"),
        String::from("world"),
    ];
    println!("Original vector: {:?}", words);

    if let Some(first) = take_first_word(&words) {
        println!("The First Word: {}", first);
    }

    let removed = remove_and_return(&mut words, 1);
    println!("Remove Index 1: {:?}, Remaining: {:?}", removed, words);

    let mut numbers = vec![10, 20, 30, 40, 50];
    while let Some(val) = numbers.pop() {
        println!("Pop up: {}", val);
    }
    println!("The vector is empty: {:?}", numbers);

    let s1 = String::from("foo");
    let s2 = String::from("bar");
    let combined = s1 + &s2;
    println!("Stitching Results: {}", combined);

    let data = vec![String::from("a"), String::from("b")];
    for word in &data {
        println!("Borrow: {}", word);
    }
    println!("The vector is still available: {:?}", data);

    let data2 = vec![1, 2, 3];
    for num in data2 {
        println!("Consumption: {}", num);
    }
}

Original vector: ["hello", "rust", "world"]
The First Word: hello
Remove Index 1: Some(20), Remaining: ["hello", "world"]
Pop up: 50
Pop up: 40
Pop up: 30
Pop up: 20
Pop up: 10
The vector is empty: []
Stitching Results: foobar
Borrow: a
Borrow: b
The vector is still available: ["a", "b"]
Consumption: 1
Consumption: 2
Consumption: 3