Using Structs to Structure Related Data

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

fn main() {
  let user1 = User {
    email: String::from("some@example.com"),
    username: String::from("someusername"),
    active: true,
    sign_in_count: 1,
}

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

fn build_user2(email: String, username: String) -> User {
    User {
        email,
        username,
        active: true,
        sign_in_count: 1,
    }
}

fn main() {
    // --snip--
    let user2 = User {
        email: String::from("another@example.com"),
        active: user1.active,
        sign_in_count: user1.sign_in_count,
        username: user1.username,
    };
    
    let user3 = User {
        email: String::from("another@example.com"),
        ..user1
    };
}

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

fn main() {
    let black = Color(0, 0, 0);
    let origin = Point(0, 0, 0);
}

struct UnitLikeStruct;

fn main() {
    let unit_like_struct = UnitLikeStruct;
}

fn main() {
    let width1 = 30;
    let height1 = 50;

    println!(
        "The area of the rectangle is {} square pixels.",
        area(width1, height1)
    );
}

fn main() {
    let rect1 = (30, 50);

    println!(
        "The area of the rectangle is {} square pixels.",
        area(rect1)
    );
}

fn area(dimensions: (u32, u32)) -> u32 {
    dimensions.0 * dimensions.1
}

fn main() {
    let rect1 = Rectangle { width: 30, height: 50 };

    println!(
        "The area of the rectangle is {} square pixels.",
        area(&rect1)
    );
}

fn area(rectangle: &Rectangle) -> u32 {
    rectangle.width * rectangle.height
}

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

fn main() {
    let rect1 = Rectangle { width: 30, height: 50 };

    println!("rect1 is {}", rect1);
}

   = help: the trait `std::fmt::Display` is not implemented for `Rectangle`
   = note: in format strings you may be able to use `{:?}` (or {:#?} for pretty-print) instead

fn main() {
    let rect1 = Rectangle { width: 30, height: 50 };

    println!("rect1 is {:?}", rect1);
}

   = note: `Rectangle` cannot be formatted using `{:?}` because it doesn't implement `std::fmt::Debug`

#[derive(Debug)]
struct Rectangle {
    width: u32,
    height: u32,
}

fn main() {
    let rect1 = Rectangle { width: 30, height: 50 };

    println!("rect1 is {:?}", rect1);
}

#[derive(Debug)]
struct Rectangle {
    width: u32,
    height: u32,
}

fn main() {
    let scale = 2;
    let rect1 = Rectangle {
        width: dbg!(30 * scale),
        height: 50,
    };

    dbg!(&rect1);
}

$ cargo run
   Compiling rectangles v0.1.0 (file:///projects/rectangles)
    Finished dev [unoptimized + debuginfo] target(s) in 0.61s
     Running `target/debug/rectangles`
[src/main.rs:10] 30 * scale = 60
[src/main.rs:14] &rect1 = Rectangle {
    width: 60,
    height: 50,
}

#[derive(Debug)]
struct Rectangle {
    width: u32,
    height: u32,
}

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

fn main() {
    let rect1 = Rectangle {
        width: 30,
        height: 50,
    };

    println!(
        "The area of the rectangle is {} square pixels.",
        rect1.area()
    );
}

struct Circle {
    radius: f64,
}

impl Circle {
    // Circle의 면적을 계산하는 메서드
    fn area(&self) -> f64 {
        3.14159 * self.radius * self.radius
    }

    // Circle의 반지름을 주어진 배율로 조정하는 메서드
    fn scale(&mut self, factor: f64) {
        self.radius *= factor;
    }
}

fn main() {
    let mut circle = Circle { radius: 5.0 };

    println!("원래 면적: {}", circle.area());

    // circle의 반지름을 2배로 조정
    circle.scale(2.0);

    println!("조정된 면적: {}", circle.area());
}

impl Circle {
    // Circle을 Square로 변환하는 메서드
    fn into_square(self) -> Square {
        Square { side: self.radius * 2.0 }
    }
}

struct Square {
    side: f64,
}

fn main() {
    let circle = Circle { radius: 5.0 };
    let square = circle.into_square(); // 여기서 circle의 소유권이 이동됨

    // println!("원의 반지름: {}", circle.radius); // 오류: `circle`은 더 이상 유효하지 않음
    println!("정사각형의 변 길이: {}", square.side);
}

fn main() {
    let circle = Circle { radius: 5.0 };

    // circle.scale(2.0); // 오류: `circle`은 불변 참조이며, `scale`은 가변 참조를 요구함
}

// same
p1.distance(&p2);
(&p1).distance(&p2);

fn main() {
    let rect1 = Rectangle {
        width: 30,
        height: 50,
    };
    let rect2 = Rectangle {
        width: 10,
        height: 40,
    };
    let rect3 = Rectangle {
        width: 60,
        height: 45,
    };

    println!("Can rect1 hold rect2? {}", rect1.can_hold(&rect2));
    println!("Can rect1 hold rect3? {}", rect1.can_hold(&rect3));
}

impl Rectangle {
    fn can_hold(&self, other: &Rectangle) -> bool {
        self.width > other.width && self.height > other.height
    }
}

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