Rust for C-Programmers

Exercise 1: Defining and Using a Struct

Define a Rectangle struct with width and height. Implement methods to calculate the rectangle’s area and perimeter:

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: 10, height: 20 };
    println!("Area: {}", rect.area());
    println!("Perimeter: {}", rect.perimeter());
}

Exercise 2: Generic Struct

Create a generic Pair<T, U> struct holding two values of possibly different types. Add a method to return a reference to the first value:

struct Pair<T, U> {
    first: T,
    second: U,
}

impl<T, U> Pair<T, U> {
    fn first(&self) -> &T {
        &self.first
    }
}

fn main() {
    let pair = Pair { first: "Hello", second: 42 };
    println!("First: {}", pair.first());
}

Exercise 3: Struct with References and Lifetimes

Define a Book struct referencing a title and an author, indicating lifetimes explicitly:

struct Book<'a> {
    title: &'a str,
    author: &'a str,
}

fn main() {
    let title = String::from("Rust Programming");
    let author = String::from("John Doe");

    let book = Book {
        title: &title,
        author: &author,
    };

    println!("{} by {}", book.title, book.author);
}

Exercise 4: Implementing and Using Traits

Derive Debug and PartialEq for a Point struct, then create instances and compare them:

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

fn main() {
    let p1 = Point { x: 1, y: 2 };
    let p2 = Point { x: 1, y: 2 };

    println!("{:?}", p1);
    println!("Points are equal: {}", p1 == p2);
}

Exercise 5: Method Consuming Self

Implement a method that consumes a Person instance, returning one of its fields. This highlights ownership in methods:

struct Person {
    name: String,
    age: u8,
}

impl Person {
    fn into_name(self) -> String {
        self.name
    }
}

fn main() {
    let person = Person { name: String::from("Ivy"), age: 29 };
    let name = person.into_name();
    println!("Name: {}", name);
    // `person` is no longer valid here as it was consumed by `into_name()`
}