References and functions

Pass references into functions and return them.

References and functions

A function signature states clearly what will be done with the value:

fn f(v: Vec<i32>) — takes ownership (consumes it).
fn f(v: &Vec<i32>) or &[i32] — only reads.
fn f(v: &mut Vec<i32>) — changes it in place.

fn toplam(v: &[i32]) -> i32 { v.iter().sum() }
fn ikiye_katla(v: &mut Vec<i32>) {
    for x in v.iter_mut() { *x *= 2; }
}

iter and iter_mut

iter() gives elements as &T, iter_mut() as &mut T. The second is used to change elements in place, and each element is dereferenced with *:

let mut fiyatlar = vec![10.0, 20.0];
for f in fiyatlar.iter_mut() {
    *f *= 1.2;
}
println!("{:?}", fiyatlar);   // [12.0, 24.0]

Writing for x in &mut v is the same as v.iter_mut().

Exercise Read and modify

Write the functions fn toplam(v: &[i32]) -> i32 and fn ikiye_katla(v: &mut Vec<i32>). For let mut v = vec![1, 2, 3];, call ikiye_katla(&mut v) first, then toplam(&v), and print v and the sum.

Show example solution

fn toplam(v: &[i32]) -> i32 {
    v.iter().sum()
}

fn ikiye_katla(v: &mut Vec<i32>) {
    for x in v.iter_mut() {
        *x *= 2;
    }
}

fn main() {
    let mut v = vec![1, 2, 3];
    ikiye_katla(&mut v);
    let t = toplam(&v);
    println!("{:?} {}", v, t);
}

Test yourself

For a function that only reads a vector, which parameter is most flexible?
- &mut Vec<i32>
- &Vec<i32>
- &[i32]
- Vec<i32>
Show answer

&[i32] — A slice reference accepts &Vec<i32>, arrays and sub-slices; &Vec accepts only a vector.

Change in place

for x in v.____() {
    *x += 1;
}

Show answer

for x in v.iter_mut() {
    *x += 1;
}

Signature and intent

v: Vec<T>

Consumes
v: &[T]

Reads
v: &mut Vec<T>

Modifies
v.iter_mut()

&mut T elements

Next lesson: Summary - Borrowing

We Are Enhancing Your Experience

Cookie Preferences

Strictly Necessary Cookies

Analytical Cookies