函数基础 #

fn greet() {
    println!("Hello, Rust!");
}

fn main() {
    greet();
}

fn main() {
    greet();  // 可以调用后面定义的函数
}

fn greet() {
    println!("Hello!");
}

fn greet(name: &str) {
    println!("Hello, {}!", name);
}

fn main() {
    greet("Alice");
}

fn print_info(name: &str, age: u32) {
    println!("{} is {} years old", name, age);
}

fn main() {
    print_info("Alice", 30);
}

fn add(a: i32, b: i32) -> i32 {
    a + b
}

fn main() {
    let result = add(5, 3);
    println!("Result: {}", result);
}

fn add(a: i32, b: i32) -> i32 {
    a + b
}

fn main() {
    let sum = add(5, 3);
    println!("Sum: {}", sum);
}

fn abs(x: i32) -> i32 {
    if x < 0 {
        return -x;
    }
    x
}

fn main() {
    println!("abs(-5) = {}", abs(-5));
    println!("abs(5) = {}", abs(5));
}

fn add(a: i32, b: i32) -> i32 {
    a + b  // 无分号，作为返回值
}

fn add_with_semicolon(a: i32, b: i32) -> i32 {
    return a + b;  // 使用 return
}

fn greet(name: &str) {
    println!("Hello, {}!", name);
}

// 等价于
fn greet_explicit(name: &str) -> () {
    println!("Hello, {}!", name);
}

fn main() {
    let x = 5;  // 语句
}

fn main() {
    let y = {
        let x = 3;
        x + 1  // 表达式，返回 4
    };
    
    println!("y = {}", y);
}

fn main() {
    let x = 5;
    
    // 表达式（无分号）
    let y = {
        x + 1
    };
    println!("y = {}", y);  // 6
    
    // 语句（有分号）
    let z = {
        x + 1;  // 返回 ()
    };
    println!("z = {:?}", z);  // ()
}

fn take_ownership(s: String) {
    println!("{}", s);
}

fn main() {
    let s = String::from("hello");
    take_ownership(s);
    // println!("{}", s);  // 错误：s 已移动
}

fn borrow_string(s: &String) {
    println!("{}", s);
}

fn main() {
    let s = String::from("hello");
    borrow_string(&s);
    println!("{}", s);  // 正确：s 仍然有效
}

fn append_world(s: &mut String) {
    s.push_str(", world");
}

fn main() {
    let mut s = String::from("hello");
    append_world(&mut s);
    println!("{}", s);  // hello, world
}

fn give_ownership() -> String {
    String::from("hello")
}

fn take_and_return(s: String) -> String {
    s
}

fn main() {
    let s1 = give_ownership();
    println!("{}", s1);
    
    let s2 = take_and_return(s1);
    // println!("{}", s1);  // 错误：s1 已移动
    println!("{}", s2);
}

fn square(x: i32) -> i32 {
    x * x
}

fn cube(x: i32) -> i32 {
    x * x * x
}

fn factorial(n: u32) -> u32 {
    if n <= 1 {
        1
    } else {
        n * factorial(n - 1)
    }
}

fn main() {
    println!("square(5) = {}", square(5));
    println!("cube(3) = {}", cube(3));
    println!("factorial(5) = {}", factorial(5));
}

fn first_word(s: &str) -> &str {
    let bytes = s.as_bytes();
    
    for (i, &item) in bytes.iter().enumerate() {
        if item == b' ' {
            return &s[0..i];
        }
    }
    
    &s[..]
}

fn main() {
    let s = "hello world";
    let word = first_word(s);
    println!("第一个单词: {}", word);
}

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

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

fn main() {
    let mut rect = Rectangle::new(10, 20);
    println!("面积: {}", rect.area());
    
    rect.scale(2);
    println!("缩放后面积: {}", rect.area());
}