Accessing fields in Rust

Introduction

Accessing fields lets you get or change the information stored inside a data structure like a struct.

When you want to read a person's name stored in a struct.

When you need to update the age of a user in your program.

When you want to get the width or height from a rectangle struct to calculate area.

When you want to print details stored inside a struct to show to the user.

Syntax

Rust

struct StructName {
    field_name: FieldType,
    // other fields
}

let instance = StructName { field_name: value, /* ... */ };

// Access field
let value = instance.field_name;

Use a dot (.) after the instance name to access a field.

Fields must be public (with pub) if accessed from another module.

Examples

Access the name field of the person instance to print it.

Rust

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

let person = Person { name: String::from("Alice"), age: 30 };

println!("Name: {}", person.name);

Change the x field of a mutable struct instance.

Rust

struct Point {
    x: i32,
    y: i32,
}

let mut point = Point { x: 5, y: 10 };
point.x = 15; // change x value
println!("Point is at ({}, {})", point.x, point.y);

Sample Program

This program creates a Car struct and prints its fields by accessing them.

Rust

struct Car {
    make: String,
    year: u32,
}

fn main() {
    let car = Car { make: String::from("Toyota"), year: 2020 };
    println!("Car make: {}", car.make);
    println!("Car year: {}", car.year);
}

Important Notes

You can only access fields of a struct instance using the dot (.) operator.

If the struct or its fields are private, you cannot access them from outside their module.

Mutable instances allow you to change field values; immutable ones do not.

Summary

Use the dot (.) operator to access fields of a struct instance.

Fields hold the data inside structs and can be read or changed if allowed.

Make sure the struct and fields are accessible where you want to use them.

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