# Referencing and Dereferencing in Rust
## Scenario 1
```rust
struct Student {
name: String,
grade: Option<u32>,
}
fn get_grade_version_1(
// Pass student_name as a reference to avoid moving the String and transferring ownership.
// This is efficient because it avoids copying or transferring large data,
// especially for heap-allocated items.
student_name: &String,
// Pass student_db as a reference to avoid moving the entire Vec<Student>,
// which could involve a costly transfer of ownership or copying the collection
student_db: &Vec<Student>,
) -> Option<u32> {
// here, temporarily use Option::None as a placeholder return value to
// indicate no matching student found
for stu in student_db {
// !!! here use the dereferencing (*) to access the value of the student_name reference !!!
// !!! this is because student_name is a reference, but stu.name is an owned String --> it is owned by the stu even though Vec<Student> is a reference
// simply speaking stu.name is a type of String
// student_name is a type of reference(&String)
// String and &String are two types, one is data on heap, the other is address of the heap
// two types cannot compare directly
if stu.name == *student_name {
return stu.grade;
}
}
Option::None
}
fn get_grade_version_2(
student_name: &String,
student_db: &Vec<Student>,
) -> Option<u32> {
for stu in student_db {
// !!! but, we directly use student_name that skip the explicit '*' this is ok !!!
// !!! this is because when comparing &String with String Rust's PartialEq for String and &String handles the dereferencing interally
// so this expression will also work as expected
if stu.name = student_name {
return stu.grade;
}
}
}
fn main() {
let student_db = vec![
Student {
name: String::from("Alice"),
grade: Some(98),
},
Student {
name: "Bob".to_string(),
grade: Some(91),
},
Student {
name: "Mae".to_string(),
grade: Option::None,
},
];
}
```
### Explanation of Key Concepts:
#### Passing references for efficiency
Both students_name and student_db are passed as references(&String and &Vec<Student> respectively) to avoid transfering ownershp. This is important because transferring ownershp would prevent the original variables from being used further might involve necessary copying.
#### Dereferencing
Since student_name is a reference (&String) using *student_name dereferencing it to access the String it points to. This is necessary because stu.name is an owned String, and you cannot compare &String with a String.
Alternatively, you could compare without explicit dereferencing by using the fact that Rust's PartialEq implementation for String and &String which allows direct comparision.
