Accessing fields in Rust - Step-by-Step Execution

Concept Flow - Accessing fields

Define struct with fields

↓

Create instance of struct

↓

Access field using dot syntax

↓

Use or print field value

↓

END

This flow shows how to define a struct, create an instance, access its fields using dot syntax, and then use the field values.

Execution Sample

Rust

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

fn main() {
    let p = Person { name: String::from("Alice"), age: 30 };
    println!("{} is {} years old", p.name, p.age);
}

This code defines a Person struct, creates an instance, and prints the name and age fields.

Execution Table

Step	Action	Code Line	Variable/Field	Value	Output
1	Define struct Person with fields name and age	struct Person { name: String, age: u32 }	-	-	-
2	Create instance p of Person	let p = Person { name: String::from("Alice"), age: 30 };	p.name	"Alice"	-
2	Create instance p of Person	let p = Person { name: String::from("Alice"), age: 30 };	p.age	30	-
3	Access p.name and p.age to print	println!("{} is {} years old", p.name, p.age);	p.name	"Alice"	Alice is 30 years old
3	Access p.name and p.age to print	println!("{} is {} years old", p.name, p.age);	p.age	30	Alice is 30 years old

💡 Program ends after printing the person's name and age.

Variable Tracker

Variable	Start	After Creation	Final
p.name	-	"Alice"	"Alice"
p.age	-	30	30

Key Moments - 2 Insights

Why do we use dot (.) to access fields like p.name?

The dot syntax is how Rust lets you get the value inside a struct's field. See execution_table step 3 where p.name is accessed to print.

What happens if we try to access a field that does not exist?

Rust will give a compile error because the field is not defined in the struct. This is checked before running, so no step in execution_table shows this.

Visual Quiz - 3 Questions

Look at the execution_table, what is the value of p.age after creation?

A 30

B "Alice"

C 0

D Undefined

💡 Hint

Check the variable_tracker row for p.age after creation.

At which step is the field p.name accessed for output?

A Step 1

B Step 2

C Step 3

D No access in this code

💡 Hint

Look at execution_table rows where output is produced.

If we change p.name to "Bob", what changes in the execution_table output?

A Output remains 'Alice is 30 years old'

B Output changes to 'Bob is 30 years old'

C Program crashes

D p.age changes to 0

💡 Hint

Output depends on the value of p.name shown in execution_table step 3.

Concept Snapshot

struct StructName { field1: Type1, field2: Type2 }
let instance = StructName { field1: val1, field2: val2 };
Access fields with dot: instance.field1
Use fields to read or modify data
Rust checks fields at compile time

Full Transcript

This example shows how to define a struct named Person with fields name and age. Then we create an instance p with name "Alice" and age 30. Using dot syntax, we access p.name and p.age to print the message 'Alice is 30 years old'. The dot operator accesses the fields inside the struct instance. Variables p.name and p.age hold the values after creation and remain unchanged. Trying to access a non-existent field causes a compile error. Changing p.name changes the printed output accordingly.

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