测验：Rust 内存管理要点

let greeting = philosopher.clone();

let greeting = &philosopher;

let greeting = &philosopher[..];

fn borrow_it(text: &String) {
    println!("Inside: {}", text);
}
borrow_it(&wisdom);  // Now wisdom can be used after

take_knowledge(wisdom.clone());  // Original wisdom remains valid

fn take_and_return(text: String) -> String {
    println!("Inside: {}", text);
    text  // Return ownership back
}
let wisdom = take_and_return(wisdom);  // Reassign returned ownership

let mut wisdom = String::from("He who laughs at");
{
    let ref1 = &mut wisdom;
    ref1.push_str(" himself never runs");
}  // ref1 goes out of scope
let ref2 = &mut wisdom;  // Now this is valid
ref2.push_str(" out of things to laugh at.");

let mut wisdom = String::from("He who laughs at");
let ref1 = &mut wisdom;
ref1.push_str(" himself never runs out of things to laugh at.");

fn first_word<'a>(s: &'a str) -> &'a str {
    // ... same implementation
}

// These don't need explicit lifetimes
fn get_str(s: &str) -> &str { s }
fn get_first(s: &str) -> &str { &s[0..1] }

// These would need explicit lifetimes
fn longest<'a>(x: &'a str, y: &'a str) -> &'a str {
    if x.len() > y.len() { x } else { y }
}

#[derive(Debug)]
enum CatList {
    Cons(i32, Box<CatList>),  // Box provides a fixed-size pointer
    Nil,
}

fn main() {
    let catlist = CatList::Cons(1,
        Box::new(CatList::Cons(2,
            Box::new(CatList::Cons(3,
                Box::new(CatList::Nil))))));
}

use std::rc::Rc;

fn demonstrate_rc() {
    let original = Rc::new(String::from("Shared"));
    println!("Count after creation: {}", Rc::strong_count(&original)); // 1

    {
        let copy = Rc::clone(&original);
        println!("Count inside scope: {}", Rc::strong_count(&original)); // 2
    } // copy is dropped here

    println!("Count after scope: {}", Rc::strong_count(&original)); // 1
}

// Single lifetime parameter
struct Philosopher<'a> {
    name: &'a str,
    quote: &'a str,
}

// Or different lifetimes if needed
struct PhilosopherFlex<'n, 'q> {
    name: &'n str,
    quote: &'q str,
}

// Own the data instead
struct PhilosopherOwned {
    name: String,
    quote: String,
}

// Mixed ownership
struct PhilosopherMixed<'a> {
    name: String,      // Owned
    quote: &'a str,    // Borrowed
}

// Correct version with explicit lifetime annotation
fn longest<'a>(text1: &'a str, text2: &'a str) -> &'a str {
    if text1.len() > text2.len() {
        text1
    } else {
        text2
    }
}

// Alternative with different lifetimes
fn longest_flex<'a, 'b>(text1: &'a str, text2: &'b str) -> &'a str {
    if text1.len() > text2.len() {
        text1
    } else {
        text2.to_string().as_str() // Won't compile! Shows why we need same lifetime
    }
}

// Single input reference - elision works
fn first_word(s: &str) -> &str { /* ... */ }

// Multiple references, same lifetime needed
fn compare_str<'a>(s1: &'a str, s2: &'a str) -> &'a str { /* ... */ }

// Different lifetimes possible
fn combine<'a, 'b>(s1: &'a str, s2: &'b str) -> String { /* ... */ }

use std::cell::RefCell;

fn demonstrate_refcell() {
    let data = RefCell::new(42);

    // Correct way to use RefCell
    {
        let mut first = data.borrow_mut();
        *first += 1;
    } // first is dropped here

    // Now we can borrow again
    let second = data.borrow_mut();

    // Or multiple immutable borrows
    let read1 = data.borrow();
    let read2 = data.borrow(); // This is OK
}

use std::cell::{Cell, RefCell};

// Cell for Copy types
struct Counter {
    count: Cell<i32>,
}

impl Counter {
    fn increment(&self) {
        self.count.set(self.count.get() + 1);
    }
}

// RefCell for non-Copy types
struct Logger {
    messages: RefCell<Vec<String>>,
}

impl Logger {
    fn log(&self, msg: &str) {
        self.messages.borrow_mut().push(msg.to_string());
    }
}

use std::rc::Rc;
use std::cell::RefCell;

// Shared ownership in data structures
struct Node {
    next: Option<Rc<Node>>,
    value: i32,
}

// Combining with interior mutability
struct SharedState {
    data: Rc<RefCell<Vec<String>>>,
}

// Multiple owners of same data
let original = Rc::new(vec![1, 2, 3]);
let clone1 = Rc::clone(&original);
let clone2 = Rc::clone(&original);

// Single-threaded scenario with RefCell
use std::cell::RefCell;

struct SingleThreaded {
    data: RefCell<Vec<i32>>,
}

impl SingleThreaded {
    fn modify(&self) {
        self.data.borrow_mut().push(42);
    }
}

// Multi-threaded scenario with RwLock
use std::sync::RwLock;

struct ThreadSafe {
    data: RwLock<Vec<i32>>,
}

impl ThreadSafe {
    fn modify(&self) {
        self.data.write().unwrap().push(42);
    }
}

use std::sync::{Arc, Mutex};

// Correct way - Release lock before acquiring it again
fn safe_mutex() {
    let lock = Arc::new(Mutex::new(42));

    {
        let mut data = lock.lock().unwrap();
        *data += 1;
    } // Lock is released here

    // Now we can acquire it again
    let data2 = lock.lock().unwrap();
    println!("Value: {}", data2);
}

// Using multiple mutexes safely
fn multiple_mutexes() {
    let lock1 = Arc::new(Mutex::new(42));
    let lock2 = Arc::new(Mutex::new(43));

    // Always acquire locks in the same order
    let guard1 = lock1.lock().unwrap();
    let guard2 = lock2.lock().unwrap();
}

// Thread-safe counter
struct Counter {
    count: Arc<Mutex<i32>>,
}

impl Counter {
    fn increment(&self) {
        let mut count = self.count.lock().unwrap();
        *count += 1;
    } // Lock automatically released here
}

use std::rc::{Rc, Weak};
use std::cell::RefCell;

// Parent-child tree structure avoiding reference cycles
struct Node {
    next: Option<Rc<Node>>,
    parent: RefCell<Weak<Node>>,  // Weak to prevent cycles
    value: i32,
}

impl Node {
    fn new(value: i32) -> Rc<Node> {
        Rc::new(Node {
            next: None,
            parent: RefCell::new(Weak::new()),
            value,
        })
    }

    fn set_parent(&self, parent: &Rc<Node>) {
        *self.parent.borrow_mut() = Rc::downgrade(parent);
    }

    fn get_parent(&self) -> Option<Rc<Node>> {
        self.parent.borrow().upgrade()
    }
}

use std::fs::File;
use std::io::{self, Write};

struct FileWrapper {
    file: File,
    path: String,
}

impl FileWrapper {
    fn new(path: &str) -> io::Result<FileWrapper> {
        Ok(FileWrapper {
            file: File::create(path)?,
            path: path.to_string(),
        })
    }

    fn write(&mut self, content: &str) -> io::Result<()> {
        self.file.write_all(content.as_bytes())
    }
}

impl Drop for FileWrapper {
    fn drop(&mut self) {
        // Ensure file is properly closed
        // Could also do cleanup like deletion
        println!("Closing file: {}", self.path);
    }
}

// Types that can be Copy
#[derive(Copy, Clone)]
struct Point {
    x: i32,
    y: i32,
}

// Types that can only be Clone
#[derive(Clone)]
struct ComplexData {
    name: String,    // String can't be Copy
    points: Vec<i32> // Vec can't be Copy
}

// Manual implementation example
#[derive(Debug)]
struct Custom {
    data: Vec<i32>,
    identifier: u32,
}

impl Clone for Custom {
    fn clone(&self) -> Self {
        Custom {
            data: self.data.clone(),
            identifier: self.identifier,  // Copy type
        }
    }
}

// Typical current 64-bit Rust layout: 32 bytes
struct Metadata {
    id: u32,       // 4 bytes
    name: String,  // 24 bytes on 64-bit systems
    active: bool   // 1 byte + padding/alignment
}

// Reordering fields may reduce padding for repr(C) structs,
// but default Rust layout is not a stable ABI guarantee.
struct OptimizedMetadata {
    name: String,   // 24 bytes
    id: u32,       // 4 bytes
    active: bool    // 1 byte + 3 padding
}

// Further optimization with packing
#[repr(packed)]
struct PackedMetadata {
    id: u32,
    active: bool,
    name: String,
}

use std::ops::Range;

// High-level abstraction
trait ZeroCost {
    fn process(&self) -> u32;
}

impl ZeroCost for Range<u32> {
    fn process(&self) -> u32 {
        self.fold(0, |acc, x| acc + x)
    }
}

// Compiles to essentially the same code as:
fn manual_process(range: Range<u32>) -> u32 {
    let mut sum = 0;
    let mut i = range.start;
    while i < range.end {
        sum += i;
        i += 1;
    }
    sum
}

// Even more abstractions, still zero-cost
fn complex_processing<T>(data: &[T]) -> u32
where T: AsRef<str> {
    data.iter()
        .map(|s| s.as_ref().len())
        .filter(|&n| n > 3)
        .fold(0, |acc, n| acc + n as u32)
}