Accessing fields in Rust - Interactive Code Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to access the field name of the struct Person.

Rust

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

fn main() {
    let person = Person { name: String::from("Alice"), age: 30 };
    println!("Name: {}", person.[1]);
}

Drag options to blanks, or click blank then click option'

Aname

Bage

Cperson

DName

Attempts:

3 left

💡 Hint

Common Mistakes

Using the struct name instead of the field name after the dot.

Using incorrect capitalization for the field name.

To access a field of a struct in Rust, use dot notation with the exact field name. Here, person.name accesses the name field.

2fill in blank

medium

Complete the code to access the field age of the struct Employee.

Rust

struct Employee {
    id: u32,
    age: u8,
}

fn main() {
    let emp = Employee { id: 101, age: 45 };
    println!("Employee age: {}", emp.[1]);
}

Drag options to blanks, or click blank then click option'

Aid

BAge

Cemp

Dage

Attempts:

3 left

💡 Hint

Common Mistakes

Using the struct variable name instead of the field name.

Capitalizing the field name incorrectly.

Use dot notation with the exact field name to access it. Here, emp.age gets the age field.

3fill in blank

hard

Fix the error in accessing the field title of the struct Book.

Rust

struct Book {
    title: String,
    pages: u32,
}

fn main() {
    let book = Book { title: String::from("Rust Guide"), pages: 250 };
    println!("Book title: {}", book.[1]);
}

Drag options to blanks, or click blank then click option'

Abook

Btitle

Cpages

DTitle

Attempts:

3 left

💡 Hint

Common Mistakes

Using capitalized field name Title instead of title.

Trying to access the struct variable instead of a field.

Field names are case sensitive. The correct field is title in lowercase, so use book.title.

4fill in blank

hard

Fill both blanks to create a struct Car and access its model field.

Rust

struct [1] {
    model: String,
    year: u16,
}

fn main() {
    let my_car = [2] { model: String::from("Tesla"), year: 2022 };
    println!("Car model: {}", my_car.model);
}

Drag options to blanks, or click blank then click option'

ACar

Bcar

DVehicle

Attempts:

3 left

💡 Hint

Common Mistakes

Using different names or different capitalization for the struct and instance.

Using a variable name instead of the struct name in the declaration.

The struct name must be the same when declared and when creating an instance. Both blanks should be Car.

5fill in blank

hard

Fill all three blanks to define a struct Point, create an instance, and access the x field.

Rust

struct [1] {
    x: i32,
    y: i32,
}

fn main() {
    let p = [2] { x: 10, y: 20 };
    println!("X coordinate: {}", p.[3]);
}

Drag options to blanks, or click blank then click option'

APoint

Cx

Dpoint

Attempts:

3 left

💡 Hint

Common Mistakes

Using different names or capitalization for the struct and instance.

Accessing a field that does not exist or misspelling the field name.

The struct name is Point, the instance is created with Point, and the field accessed is x.

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