The std::vector Class

A std::vector stores its elements in order, and you usually reach one of them with the subscript operator, written v[i]. That syntax is convenient, but it raises a practical question: what happens when i does not name a real element? This article answers that question and shows how a programmer can change the behavior of the subscript without changing the way it is written at the call site.

The solution is a class called Vec. It takes over the subscript operations of std::vector while keeping everything else the same. Read the class carefully once you reach it, and focus on the two operator functions and the single call each of them makes. Those two details carry the whole idea.

Before reading the explanation, make a prediction. Suppose you have a Vec<int> holding five values, so the valid indices are 0 through 4. You then write an expression that uses index 10. The Vec operator calls at() internally. Decide what you expect the program to do.

The ordinary std::vector subscript operator does not check its index. When you write v[i], the operator takes i and gives you access to the element at that position without first verifying that i is inside the vector's range. The vector does not stop the program with a range error at that point.

The at() operation is different. Calling v.at(i) performs the range check, and it returns the element when the index is valid. When the index is outside the vector's range, at() throws an out_of_range exception. So the two operations share the same job of reaching an element, but only at() reports a bad index in a way the program can catch.

The diagram shows the five valid cells and a requested index that lies outside them. The plain subscript carries no check of its own, so nothing in that access is set up to report the mismatch as an exception. The difference from at() lies entirely in whether the range check happens.

Redefining a member function in a derived class replaces the behavior that a caller sees when using the derived object. This is the mechanism that makes range checking possible here. A caller writes v[i] on a Vec object, and the derived class's version of the operator is the one that runs.

The Vec class makes both kinds of subscript checked. The modifiable operator and the const operator are both redefined, so checking applies whether the object is modifiable or constant. Each redefined operator does not compute the element itself. It hands the index to the vector's at() operation, which performs the check and returns the element when the index is valid.

Notice what is absent from the Vec operators. Neither one contains an if statement or a comparison against the size of the vector. The check lives entirely inside at(), so Vec gets range checking by delegation rather than by repeating the logic. The call site v[i] stays the same, but its behavior on a bad index changes.

Follow a checked subscript step by step. The call enters the redefined operator, which forwards the index to at(). The at() operation then decides between two outcomes: it either yields the element or throws an exception. That decision point is the only place where the path can split.

The flowchart has exactly one branch point, and it sits inside at(). When the index is valid, control returns the element back through the redefined operator to the caller. When the index is outside the range, control leaves the normal return path and the out_of_range exception is thrown. The redefined operator never gets to decide the outcome itself.