References — lvalue references, difference from pointers

WHAT is an lvalue reference?

Definition lvalue reference

An lvalue reference T& is a name bound permanently to an existing object (an lvalue — something that has an address and persists). Syntax:

int x = 10;
int& r = x;   // r is now another name for x
r = 20;       // x is now 20

Key rules:

Must be initialized at declaration (int& r; is illegal).
Cannot be rebound — once r aliases x, it can never alias something else.
Cannot be null. There is no "null reference".

WHY "lvalue"? An lvalue is an expression that names a storage location (it can sit on the left of =). An lvalue reference can only bind to such a thing — you can't say int& r = 5; because 5 has no address to alias. (The exception const int& r = 5; is special and shown later.)

HOW it works under the hood

WHAT actually happens in memory: the compiler typically implements a reference like a pointer that is auto-dereferenced — but semantically there is no separate object. You never see the reference's own address; &r gives you &x.

Figure — References — lvalue references, difference from pointers

Worked example Aliasing in action — Why each step?

int x = 5;
int& r = x;     // Why: glue label r to x's box
r = 99;         // Why: write through alias -> box now holds 99
cout << x;      // prints 99  (Why: same box)
cout << (&r == &x); // prints 1 (true) (Why: same address)

References vs Pointers — the core comparison

Feature	Reference `int&`	Pointer `int*`
Is a separate object?	No (alias)	Yes (holds an address)
Must initialize?	Yes	No
Can be null?	No	Yes (`nullptr`)
Can be reseated?	No	Yes
Syntax to use	`r` (auto-deref)	`*p` (explicit deref)
Address-of gives	the original's address	the pointer's own address
Pointer arithmetic	No	Yes

WHY references exist — pass-by-reference

The biggest use: modify a caller's variable without copying.

Worked example swap — Why each step?

void swap(int& a, int& b) {  // Why &: a,b alias caller's vars
    int t = a;               // Why: stash a's value
    a = b;                   // Why: caller's a now = b
    b = t;                   // Why: caller's b now = old a
}
int x=1, y=2; swap(x, y);    // x==2, y==1, no pointers needed

Compare the C-style pointer version — uglier, needs & at call and * inside:

void swap(int* a, int* b){ int t=*a; *a=*b; *b=t; }
swap(&x, &y);

Worked example const reference — avoid a copy, forbid edits — Why?

void print(const std::string& s); // Why const&: no copy of big string,
                                   // and we promise not to modify it
print("hello");                    // Why allowed: const& may bind a temporary

A const T& can bind to a temporary/rvalue and extends its lifetime to the reference's scope. A non-const T& cannot.

Common mistakes (Steel-man + fix)

Active recall

Recall Quick self-test (cover the answers)

Can a reference be null? → No.
Can a reference be reseated to alias another variable? → No.
What does &r return for int& r = x;? → &x (same address).
Why does const int& r = 5; compile but int& r = 5; not? → const ref binds a temporary; non-const can't.
One reason to prefer const std::string& parameter over std::string? → avoids copying.

Recall Feynman: explain to a 12-year-old

Imagine your dog is named "Rex". Your little sister starts calling him "Buddy". Now the dog has two names but he's still one dog — call either name and the same dog comes running. A reference is the second nickname for a variable: two names, one thing. A pointer is different — it's like a sticky note with the dog's house address written on it. You can erase the note and write a different address (point somewhere else), or leave it blank. A nickname can never be moved to a different dog, and it can never be blank.

Connections

Pointers in C++ — the reseatable, nullable cousin
Pass-by-value vs Pass-by-reference
const correctness — const T& parameters
Rvalue references and move semantics — T&&, builds on this
Dangling references and lifetime
sizeof and object identity

What is an lvalue reference?

An alias — another name for an existing object, sharing the same memory.

Must an lvalue reference be initialized at declaration?

Yes; int& r; is illegal.

Can an lvalue reference be reseated to refer to another object later?

No, never; it stays bound to its initial object.

Can a reference be null?

No — there is no null reference.

For int& r = x;, what does &r evaluate to?

&x — the original's address (the reference has no separate address).

Why does int& r = 5; fail but const int& r = 5; succeed?

Non-const lvalue ref can't bind a temporary; const ref can and extends its lifetime.

Difference between a reference and a T* const pointer?

The const pointer is still a separate object holding an address you can inspect/deref; a reference is not a separate object.

Why prefer const std::string& over std::string as a parameter?

Avoids copying the string and forbids modifying it.

What is the danger of returning a reference to a local variable?

The local dies at return, leaving a dangling reference (undefined behavior).

In swap(int& a, int& b), why no * or & needed inside?

a and b are aliases of the caller's variables, used directly.

Concept Map

Hinglish (regional understanding)

Intuition Hinglish mein samjho

Dekho, reference ka matlab hai ek variable ka doosra naam — ek alias. Jaise int& r = x; likha, ab r aur x dono ek hi memory box ke labels hain. r me kuch likho to x bhi change ho jaata hai, kyunki box ek hi hai. Isiliye reference ko initialize karna zaroori hai declaration ke time, aur baad me usko kisi aur variable se bind nahi kar sakte — naam badal nahi sakte. Null bhi nahi ho sakta.

Pointer thoda alag cheez hai. Pointer apne aap me ek alag box hai jisme doosre variable ka address stored hota hai. Tum pointer ko nullptr bana sakte ho, dobara kisi aur variable pe point kara sakte ho, arithmetic kar sakte ho. Use karne ke liye *p se dereference karna padta hai. Reference auto-dereference hota hai, seedha r likho.

Asli faayda reference ka hai pass-by-reference me. Jaise swap(int& a, int& b) — yahan a aur b caller ke variables ke alias ban jaate hain, to function ke andar bina * aur & ke direct swap ho jaata hai. Bade objects ke liye const std::string& s use karo — copy nahi banegi (fast) aur modify bhi nahi kar paoge (safe).

Yaad rakhne wali galti: reference ko mat samajhna "const pointer". Semantically reference koi alag object hai hi nahi — &r tumhe x ka hi address dega, aur local variable ka reference return karna mat, warna woh dangle kar jaata hai (UB). Rule simple: A.R.N. — Alias, Ready (init zaroori), Never change.

References — lvalue references, difference from pointers

WHAT is an lvalue reference?

HOW it works under the hood

References vs Pointers — the core comparison

WHY references exist — pass-by-reference

Common mistakes (Steel-man + fix)

Active recall

Connections

Concept Map

Hinglish (regional understanding)

Go deeper — visual, from zero

Test yourself — C++ Programming

Connections