Rust Developer -

A reference in Rust lets you point to a value without taking ownership of it. You create an immutable reference with the & operator and access the referenced value with the dereference operator *. The original variable still owns its data and remains valid. You can create multiple references to the same value. Dereferencing happens automatically in many cases, such as inside println!. This lesson covers the basics of creating and using references.

fn main() {
    let x = 5;
    let r = &x;
    println!("{}", r);
}

• let x = 5; binds the value 5 to x.
• let r = &x; creates a reference r that points to x without taking ownership.
• Passing r to println! automatically dereferences and prints 5.
• The variable x still owns the value and can be used later.
• References are non-owning pointers — they borrow the value.

fn main() {
    let x = 10;
    let r = &x;
    println!("{}", *r);
}

• The *r syntax explicitly dereferences the reference to get the value.
• println! can also print the reference directly because it knows how to display integers.
• Dereferencing gives you access to the underlying i32 value.
• The output is 10.
• Using * is called the dereference operator.

fn main() {
    let x = 42;
    let r1 = &x;
    let r2 = &x;
    println!("{} {}", r1, r2);
}

• You can create multiple references to the same value.
• Both r1 and r2 are &i32 references pointing to x.
• All references coexist peacefully as long as they are read-only.
• The output is 42 42.
• Creating a reference does not move or copy the value.

fn main() {
    let s = String::from("hi");
    let r = &s;
    println!("{}", r);
}

• You can also create references to heap-allocated types like String.
• let r = &s; borrows the String without moving it.
• The original s still owns the string data after the reference is created.
• The output is hi.
• References to String have type &String.

fn main() {
    let x = 7;
    let r = &x;
    println!("{}", x);
    println!("{}", r);
}

• The original variable remains usable after creating a reference to it.
• x is still valid and can be printed directly.
• r is a reference and prints the same value.
• Both x and r produce the output 7.
• This shows that references are non-owning — no ownership transfer occurs.

fn main() {
    let x = 3;
    let r = &x;
    let y = *r + 1;
    println!("{}", y);
}

• You can dereference a reference with * to use the value in expressions.
• *r + 1 dereferences r to get 3, then adds 1.
• The result 4 is stored in y.
• The original x remains unchanged.
• Dereferencing does not copy ownership; it only reads the value.