结构体 #

struct User {
    username: String,
    email: String,
    active: bool,
    sign_in_count: u64,
}

fn main() {
    let user = User {
        username: String::from("alice"),
        email: String::from("alice@example.com"),
        active: true,
        sign_in_count: 1,
    };
    
    println!("Username: {}", user.username);
}

fn main() {
    let mut user = User {
        username: String::from("alice"),
        email: String::from("alice@example.com"),
        active: true,
        sign_in_count: 1,
    };
    
    user.email = String::from("new@example.com");
    println!("Email: {}", user.email);
}

fn build_user(username: String, email: String) -> User {
    User {
        username,  // 简写
        email,     // 简写
        active: true,
        sign_in_count: 1,
    }
}

fn main() {
    let user1 = User {
        username: String::from("alice"),
        email: String::from("alice@example.com"),
        active: true,
        sign_in_count: 1,
    };
    
    let user2 = User {
        username: String::from("bob"),
        ..user1  // 其余字段来自 user1
    };
    
    println!("user2 email: {}", user2.email);
}

struct Color(i32, i32, i32);
struct Point(i32, i32, i32);

fn main() {
    let black = Color(0, 0, 0);
    let origin = Point(0, 0, 0);
    
    println!("Black: ({}, {}, {})", black.0, black.1, black.2);
}

fn main() {
    let color = Color(255, 128, 0);
    let Color(r, g, b) = color;
    
    println!("RGB: ({}, {}, {})", r, g, b);
}

struct AlwaysEqual;

fn main() {
    let _subject = AlwaysEqual;
}

struct Rectangle {
    width: u32,
    height: u32,
}

impl Rectangle {
    fn area(&self) -> u32 {
        self.width * self.height
    }
    
    fn perimeter(&self) -> u32 {
        2 * (self.width + self.height)
    }
}

fn main() {
    let rect = Rectangle {
        width: 30,
        height: 50,
    };
    
    println!("Area: {}", rect.area());
    println!("Perimeter: {}", rect.perimeter());
}

impl Rectangle {
    fn scale(&mut self, factor: u32) {
        self.width *= factor;
        self.height *= factor;
    }
}

fn main() {
    let mut rect = Rectangle {
        width: 10,
        height: 20,
    };
    
    rect.scale(2);
    println!("Width: {}, Height: {}", rect.width, rect.height);
}

impl Rectangle {
    fn new(width: u32, height: u32) -> Self {
        Rectangle { width, height }
    }
    
    fn square(size: u32) -> Self {
        Rectangle {
            width: size,
            height: size,
        }
    }
}

fn main() {
    let rect = Rectangle::new(10, 20);
    let square = Rectangle::square(5);
    
    println!("Rect area: {}", rect.area());
    println!("Square area: {}", square.area());
}

impl Rectangle {
    fn area(&self) -> u32 {
        self.width * self.height
    }
}

impl Rectangle {
    fn perimeter(&self) -> u32 {
        2 * (self.width + self.height)
    }
}

#[derive(Debug)]
struct User {
    username: String,
    email: String,
}

fn main() {
    let user = User {
        username: String::from("alice"),
        email: String::from("alice@example.com"),
    };
    
    println!("{:?}", user);
    println!("{:#?}", user);
}

#[derive(Debug, Clone, PartialEq)]
struct Point {
    x: i32,
    y: i32,
}

fn main() {
    let p1 = Point { x: 1, y: 2 };
    let p2 = p1.clone();
    
    println!("{:?}", p1);
    println!("p1 == p2: {}", p1 == p2);
}

#[derive(Debug)]
struct BankAccount {
    owner: String,
    balance: f64,
}

impl BankAccount {
    fn new(owner: &str, initial_balance: f64) -> Self {
        BankAccount {
            owner: owner.to_string(),
            balance: initial_balance,
        }
    }
    
    fn deposit(&mut self, amount: f64) {
        self.balance += amount;
    }
    
    fn withdraw(&mut self, amount: f64) -> Result<(), String> {
        if amount > self.balance {
            Err(String::from("余额不足"))
        } else {
            self.balance -= amount;
            Ok(())
        }
    }
    
    fn get_balance(&self) -> f64 {
        self.balance
    }
}

fn main() {
    let mut account = BankAccount::new("Alice", 1000.0);
    
    account.deposit(500.0);
    println!("存款后余额: {}", account.get_balance());
    
    match account.withdraw(200.0) {
        Ok(()) => println!("取款成功，余额: {}", account.get_balance()),
        Err(e) => println!("取款失败: {}", e),
    }
}

#[derive(Debug, Clone)]
struct Book {
    title: String,
    author: String,
    pages: u32,
    available: bool,
}

impl Book {
    fn new(title: &str, author: &str, pages: u32) -> Self {
        Book {
            title: title.to_string(),
            author: author.to_string(),
            pages,
            available: true,
        }
    }
    
    fn borrow_book(&mut self) -> Result<(), String> {
        if self.available {
            self.available = false;
            Ok(())
        } else {
            Err(format!("《{}》已被借出", self.title))
        }
    }
    
    fn return_book(&mut self) {
        self.available = true;
    }
}

fn main() {
    let mut book = Book::new("Rust编程", "Steve", 500);
    
    println!("{:?}", book);
    
    book.borrow_book().unwrap();
    println!("借出后: {:?}", book);
    
    book.return_book();
    println!("归还后: {:?}", book);
}