Const References

Suppose you own a vector of numbers called my_vec, and you want a sorting routine to rearrange it. The routine needs to touch the vector you actually own, not a duplicate that it throws away when it finishes. If the function receives a copy, the sorting happens to the copy, and your original stays unchanged. This is the problem that references solve.

Many functions do not need to rearrange anything. They compute a total, search for a value, or print a report, and they never need to change the caller's data. Even so, the way an argument is passed still matters, because it determines both what the function is allowed to do to the data and how much work the call performs. This article focuses on the tool for the read-only case: the const reference, which avoids copying while forbidding changes. Keep one question in mind as you read: when a function works on a name that refers to my_vec, is it working on my_vec itself or on something that merely looks like it?

The declaration must name the object the reference will stand for, because a reference is always tied to something at the moment it is created. This is why the initializer after the equals sign is not optional: a reference without an object to stand for has no meaning. Once the two names are in place, r and x are not two separate values in memory. There is one object, and the two names are two routes to it. Any change made through either name is visible through the other, because both names lead to the same storage.

The initializer also decides the reference's identity for life. A reference cannot be made to refer to a different object after its initialization. Writing r = 25 does not rebind r to some other variable. It assigns 25 into the object that r already refers to, which is x. The binding stays the same, and only the value inside the object changes.

This fixed binding is useful for reading code. When you see a reference, you can rely on its name always standing for the same object for its whole lifetime. You do not need to track whether it has been pointed somewhere else.

The declaration double sum(const vector<double>&) has several parts, and each one has a job. The keyword const says the referred-to object cannot be modified through this name. The type vector<double> names what is being referred to. The ampersand makes the parameter a reference rather than a copy. The leading double is the return type, so it describes the value the function gives back, not the parameter.

Reading a declaration from the inside out helps. Start at the name, then move outward through each declarator operator. For const vector<double>&, the reference operator applies to the whole const vector<double> type, which is why the parameter is described as a reference to a constant vector of doubles.

Start with a function that adds up the numbers in a vector. Its parameter is a const reference to a vector of doubles. Read the code as a plain description of behavior: the function reads each element, accumulates a running total, and returns it. The reference avoids copying the vector, and const keeps the function from changing it.

Now suppose someone edits the body so that it tries to change the vector it was given. Before you read on, predict what happens when the code is compiled.

The compiler rejects the modifying line. The const on the parameter is enforced there, not in the loop or the return statement, which behave exactly as before. When a const reference version fails, the fastest route is to locate the exact line where the behavior stops matching what you intended. In this example the divergence is the single line that changes v, and removing it restores the function that only reads.

The const reference is therefore a promise enforced by the language rather than a convention the programmer has to remember. Reads go through to the caller's data, and writes are blocked at compile time.

Passing by value copies the data and protects the caller, but it costs the work of duplicating it. Passing by non-const reference avoids copying but allows changes to the original. Passing by const reference avoids copying and blocks changes. For a function that only reads its argument, the choice comes down to two questions: does the function need to change the caller's data, and is the argument large enough that copying would be costly?

Several misunderstandings come up repeatedly when students first use references. Each one is corrected by a rule stated above.