Pass / Return by Reference

Programming Language & Its Applications — C++ Constructs with Objects and Classes, NEC licence examination syllabus (Nepal Engineering Council).

Pass / Return by Reference

A reference is an alias — another name for an existing object, with no address arithmetic in sight.

🌍 Where this lives: references are the reason C++ code reads cleanly where C code is full of * and &. Every time you write cout << x << y << z, the chaining works because operator<< returns a reference to the stream — return by value would copy the whole stream and break the chain. And every function you will ever write taking a const std::string& instead of a std::string is avoiding a heap allocation per call. Java has references for all objects and no way to opt out; Rust made them explicit again with borrow checking. Search "C++ pass by const reference vs by value" to see the modern rules, which changed with move semantics in C++11.

What a reference is

int x = 10; int &r = x; /* r is ANOTHER NAME for x */ r = 20; → x is now 20 &r == &x → true, same address sizeof(r) → sizeof(int), not a pointer size A reference is NOT an object. It has no address of its own, no arithmetic, and no null state. THE THREE RULES: 1. must be initialised at declaration int &r; ✗ error: declared as reference but not initialised 2. cannot be reseated int a=1,b=2; int &r=a; r=b; ← assigns b's VALUE to a; r still aliases a 3. cannot be null int &r = *(int*)nullptr; ← undefined behaviour, the language assumes references are valid POINTER vs REFERENCE: POINTER REFERENCE can be null yes no can be reseated yes no needs * to read yes no, use it directly arithmetic yes (p+1) no own address yes no must init no YES array of them yes no (int &a[3]; is illegal)

refs.cpp

#include <iostream>

int main() {
    int x = 10;
    int &r = x;              /* alias */
    int *p = &x;             /* pointer */

    r = 20;                  /* no dereference needed */
    *p = 30;                 /* pointer needs * */
    std::cout << "x=" << x << " r=" << r
              << " *p=" << *p << "\n";

    std::cout << "&x=" << &x << "\n&r=" << &r
              << "   (identical)\n";

    /* r cannot be reseated */
    int y = 99;
    r = y;                   /* copies 99 INTO x */
    std::cout << "after r=y:  x=" << x
              << "  y=" << y << "\n";
    p = &y;                  /* p now points at y */
    std::cout << "after p=&y: *p=" << *p << " x=" << x << "\n";
    return 0;
}
Output:
x=30 r=30 *p=30
&x=0x7ffd4a2b1c34
&r=0x7ffd4a2b1c34   (identical)
after r=y:  x=99  y=99
after p=&y: *p=99 x=99

Passing by reference

pass_ref.cpp

#include <iostream>
#include <string>

/* C style - works, but noisy at both ends */
void swap_ptr(int *a, int *b) { int t=*a; *a=*b; *b=t; }

/* C++ style - identical machine code, cleaner source */
void swap_ref(int &a, int &b) { int t=a; a=b; b=t; }

/* by value - the caller's object is untouched */
void by_value(int a) { a = 999; }

/* const reference - no copy, and cannot modify.
   THE default for any non-trivial parameter type. */
void report(const std::string &s) {
    std::cout << "len " << s.size() << ": " << s << "\n";
    /* s[0] = 'X';  <-- compile error, good */
}

int main() {
    int x = 1, y = 2;
    swap_ptr(&x, &y);  std::cout << x << " " << y << "\n";
    swap_ref(x, y);    std::cout << x << " " << y << "\n";

    int z = 5;
    by_value(z);       std::cout << "z still " << z << "\n";

    std::string big(2000, 'a');
    report(big);       /* zero bytes copied */
    return 0;
}
Output:
2 1
1 2
z still 5
len 2000: aaaaaaaa...  (2000 a's)

Why const& matters, in bytes: void f(std::string s) → copies the whole string. A 2000-char string = one heap allocation + 2000-byte memcpy, PER CALL. void f(const std::string &s) → copies 8 bytes (a hidden pointer). No allocation. Called 1,000,000 times: by value: 1,000,000 allocations + 2 GB copied by const ref: 8 MB of pointer passing, 0 allocations The modern parameter-passing rule of thumb: small & cheap to copy (int, double, pointer, ≤16 bytes) → pass BY VALUE large, or you do not know (string, vector, class) → pass BY const REFERENCE you must modify the caller's object → pass BY non-const REFERENCE the function will TAKE OWNERSHIP / store a copy → pass by value and std::move it (C++11 idiom)

The reason const& is not simply "always better" is that a reference is an indirection: reading s means following a pointer, which for an int costs more than just copying the 4 bytes. That is why the cutoff is around 16 bytes — roughly two machine words, the size that fits in registers.

Returning by reference

return_ref.cpp

#include <iostream>
#include <vector>

class Counter {
    int count = 0;
public:
    /* return *this by reference -> enables CHAINING */
    Counter& increment() { ++count; return *this; }
    Counter& add(int n)  { count += n; return *this; }
    int value() const    { return count; }
};

/* returning a reference to an ELEMENT lets you assign
   through the function call - this is how v[i] works */
int& at(std::vector<int> &v, size_t i) { return v[i]; }

/* DANGER: reference to a LOCAL. The object dies at return,
   so the caller holds a dangling reference. */
/* int& bad() { int local = 42; return local; } */

int main() {
    Counter c;
    /* chaining, only possible because each call returns
       a reference to the same object */
    c.increment().increment().add(10).increment();
    std::cout << "count = " << c.value() << "\n";

    std::vector<int> v{1, 2, 3, 4, 5};
    at(v, 2) = 99;            /* ASSIGN through a call */
    for (int n : v) std::cout << n << " ";
    std::cout << "\n";
    return 0;
}
Output:
count = 13
1 2 99 4 5

Tracing count = 13: increment() → 1 increment() → 2 add(10) → 12 increment() → 13 ✔ Each call returns Counter&, so the next .method() applies to the SAME object. If increment() returned Counter (by value) instead, each call would act on a temporary COPY and the final count would be 1. Safe to return by reference: ✔ *this ✔ a member of *this ✔ a parameter that was passed by reference ✔ a static or global object ✔ heap memory whose lifetime you control NEVER: ✗ a local variable (dies at return) ✗ a by-value parameter (also a local) ✗ a temporary (dies at end of expression) g++ warns: "reference to local variable returned" — take that warning seriously, it is a real bug every time.

Worked example — the three parameter styles measured

compare.cpp

#include <iostream>
#include <string>

struct Big { char data[1024]; int id; };   /* 1028 bytes */

int copies = 0;
struct Tracked {
    int id;
    Tracked(int i) : id(i) {}
    Tracked(const Tracked &o) : id(o.id) { ++copies; }
};

void by_value(Tracked t)        { (void)t; }
void by_cref (const Tracked &t) { (void)t; }
void by_ref  (Tracked &t)       { t.id = 99; }

int main() {
    Tracked t(1);

    copies = 0; by_value(t);
    std::cout << "by_value copies: " << copies << "\n";

    copies = 0; by_cref(t);
    std::cout << "by_cref  copies: " << copies << "\n";

    copies = 0; by_ref(t);
    std::cout << "by_ref   copies: " << copies
              << ", t.id now " << t.id << "\n";

    std::cout << "\nsizeof(Big)  = " << sizeof(Big)
              << " bytes copied by value\n";
    std::cout << "sizeof(Big&) = " << sizeof(Big*)
              << " bytes passed by reference\n";
    return 0;
}
Output:
by_value copies: 1
by_cref  copies: 0
by_ref   copies: 0, t.id now 99

sizeof(Big)  = 1032 bytes copied by value
sizeof(Big&) = 8 bytes passed by reference

The copy counter makes it visible: pass by value invokes the copy constructor, both reference forms do not. Note sizeof(Big) is 1032, not 1028 — the int id after char[1024] needs 4-byte alignment and the total rounds up, which is the padding rule from the struct topic showing up again.

References to const, and temporaries

A const reference can bind to a TEMPORARY; a non-const reference cannot. void f(int &r); void g(const int &r); f(5); ✗ error: cannot bind non-const lvalue reference to an rvalue g(5); ✔ a temporary int holding 5 is created, and its lifetime is EXTENDED to the end of the call Why the asymmetry? f(5) would let the function modify a value that has no name and will vanish — almost certainly a mistake. C++ refuses. This is exactly why const& is the safe universal parameter type: it accepts named objects, literals, and function results alike. void report(const std::string &s); report(name); ✔ an lvalue report("literal"); ✔ temporary string report(a + b); ✔ temporary result

🌍 Go further: everything above is lvalue references. C++11 added rvalue references (T&&) which bind only to temporaries — the basis of move semantics. It is why returning a big std::vector by value is now free rather than a copy: the compiler moves the internal buffer pointer instead of duplicating the data. This single feature is the biggest performance change in C++'s history. Search "C++ move semantics rvalue reference", and specifically "return value optimisation" — you will find that the "always return by reference for speed" advice you may read online is now outdated advice that makes code less safe for no gain.

💡 Exam angle: the pointer versus reference comparison table is asked directly — must be initialised, cannot be null, cannot be reseated, no arithmetic, no dereference syntax. Write swap in both styles. State when returning a reference is safe and give the dangling reference to a local as the classic error. Know that a const& binds to temporaries and a non-const reference does not, and be able to justify pass-by-const& with the copy cost.

Syllabus points

Reference parameters & return

Create a free account to tick topics off, take notes as you read, watch the video lessons and get a day-by-day study plan built around your exam date.