Accessing fields in Rust - Mini Project: Build & Apply

Accessing fields

📖 Scenario: Imagine you are creating a simple program to store and show information about a book in a library.

🎯 Goal: You will create a Book struct, set up a book with title and author, then access and print these fields.

📋 What You'll Learn

Create a struct named Book with two fields: title and author, both of type String.

Create a variable named my_book of type Book with title "The Rust Book" and author "Steve".

Access the title and author fields of my_book using dot notation.

Print the book's title and author in the format: Title: The Rust Book, Author: Steve.

💡 Why This Matters

🌍 Real World

Structs are used to group related data together, like storing information about books, users, or products.

💼 Career

Understanding how to define and access struct fields is essential for Rust programming in software development, especially in systems programming and backend services.

1

Create the Book struct

Create a struct named Book with two fields: title and author, both of type String.

Rust

# Your code here

Hint

Use struct Book { title: String, author: String } to define the book structure.

2

Create a my_book variable

Create a variable named my_book of type Book with title set to "The Rust Book" and author set to "Steve". Use String::from to create the strings.

Rust

struct Book {
    title: String,
    author: String,
}

# Your code here

Hint

Use let my_book = Book { title: String::from("The Rust Book"), author: String::from("Steve") };

3

Access the fields of my_book

Use dot notation to access the title and author fields of my_book and store them in variables named book_title and book_author.

Rust

struct Book {
    title: String,
    author: String,
}

let my_book = Book {
    title: String::from("The Rust Book"),
    author: String::from("Steve"),
};

# Your code here

Hint

Use let book_title = &my_book.title; and let book_author = &my_book.author; to get the fields.

4

Print the book's title and author

Print the book's title and author using println! in the format: Title: The Rust Book, Author: Steve. Use the variables book_title and book_author.

Rust

struct Book {
    title: String,
    author: String,
}

let my_book = Book {
    title: String::from("The Rust Book"),
    author: String::from("Steve"),
};

let book_title = &my_book.title;
let book_author = &my_book.author;

# Your code here

Hint

Use println!("Title: {}, Author: {}", book_title, book_author); to print the result.

Practice

1. In Rust, how do you access the field age of a struct instance named person?

easy

A. person::age

B. person->age

C. person["age"]

D. person.age

Solution

1. Step 1: Understand struct field access syntax

   In Rust, fields of a struct instance are accessed using the dot (.) operator.

2. Step 2: Apply the dot operator to the instance and field

   Given the instance person and field age, the correct syntax is person.age.

3. Final Answer:

   person.age -> Option D

4. Quick Check:

   Use dot (.) to access fields [OK]

Hint: Use dot (.) to access struct fields quickly [OK]

Common Mistakes:

• Using arrow (->) like in C/C++
• Trying to access fields like dictionary keys
• Using double colon (::) which is for paths

2. Which of the following is the correct way to define a struct and access its field color in Rust?

easy

A. struct Car { color: String } let my_car = Car { color: "red" }; println!("{}", my_car["color"]);

B. struct Car { color: String } let my_car = Car { color: "red" }; println!("{}", my_car->color);

C. struct Car { color: String } let my_car = Car { color: String::from("red") }; println!("{}", my_car.color);

D. struct Car { color: String } let my_car = Car { color: String::from("red") }; println!("{}", Car.color);

Solution

1. Step 1: Check struct definition and instance creation

   The struct Car is correctly defined with a field color of type String. The instance my_car is created with color: String::from("red"), which is correct.

2. Step 2: Verify field access syntax

   The field is accessed using my_car.color, which is the correct way to access struct fields in Rust.

3. Final Answer:

   struct Car { color: String } let my_car = Car { color: String::from("red") }; println!("{}", my_car.color); -> Option C

4. Quick Check:

   Struct fields accessed with dot and proper String initialization [OK]

Hint: Use String::from for strings and dot for fields [OK]

Common Mistakes:

• Using arrow (->) instead of dot (.)
• Trying to access fields like dictionary keys
• Using struct name instead of instance to access fields

3. What will be the output of this Rust code?

struct Point { x: i32, y: i32 }
fn main() {
    let p = Point { x: 10, y: 20 };
    println!("{}", p.x + p.y);
}

medium

A. 30

B. 1020

C. x y

D. Compilation error

Solution

1. Step 1: Understand struct and instance values

   The struct Point has fields x and y with values 10 and 20 respectively.

2. Step 2: Calculate the sum of fields

   The code prints the sum of p.x and p.y, which is 10 + 20 = 30.

3. Final Answer:

   30 -> Option A

4. Quick Check:

   Sum of fields x and y = 30 [OK]

Hint: Add numeric fields accessed by dot to get sum [OK]

Common Mistakes:

• Concatenating numbers as strings
• Using wrong field names
• Expecting compilation error due to field access

4. Identify the error in this Rust code snippet:

struct User { name: String, age: u32 }
fn main() {
    let user = User { name: String::from("Alice"), age: 30 };
    println!("{}", user->name);
}

medium

A. Using arrow (->) instead of dot (.) to access field

B. Missing semicolon after struct definition

C. Incorrect type for age field

D. String::from used incorrectly

Solution

1. Step 1: Check field access syntax

   The code uses user->name which is invalid in Rust. Rust uses dot (.) to access fields.

2. Step 2: Confirm other parts are correct

   The struct definition, instance creation, and String::from usage are all correct.

3. Final Answer:

   Using arrow (->) instead of dot (.) to access field -> Option A

4. Quick Check:

   Use dot (.) not arrow (->) for fields [OK]

Hint: Remember Rust uses dot (.) for fields, not arrow (->) [OK]

Common Mistakes:

• Confusing Rust with C/C++ pointer syntax
• Thinking arrow works for references
• Ignoring compiler error messages

5. Given this struct and code, what is the output?

struct Product { name: String, price: f64, discount: Option<f64> }

fn main() {
    let p = Product { name: String::from("Book"), price: 30.0, discount: Some(5.0) };
    let final_price = match p.discount {
        Some(d) => p.price - d,
        None => p.price,
    };
    println!("{} costs ${}", p.name, final_price);
}

hard

A. Book costs $35

B. Book costs $25

C. Book costs $30

D. Compilation error due to Option usage

Solution

1. Step 1: Understand struct and field values

   The Product instance p has price 30.0 and discount Some(5.0).

2. Step 2: Calculate final price using match on Option

   The match extracts discount value 5.0 and subtracts it from price: 30.0 - 5.0 = 25.0.

3. Step 3: Print output with name and final price

   The output string is Book costs $25.

4. Final Answer:

   Book costs $25 -> Option B

5. Quick Check:

   Option unwrap and arithmetic produce 25 [OK]

Hint: Use match to handle Option fields safely [OK]

Common Mistakes:

• Ignoring Option and causing runtime panic
• Using None branch incorrectly
• Confusing price and discount arithmetic