Indexing and Indirection: operator[], operator->, and operator*

01Subscript Operator (operator[]) and Const Overloading

When designing custom collections, array wrappers, or matrix buffers, providing intuitive array indexing requires overloading the subscript operator: operator[].

A properly designed container must provide TWO overloads of operator[]:

1. Non-const overload: T& operator[](size_t index);. Returns a mutable reference to the element, permitting assignments like buffer[0] = 42;.

2. Const overload: const T& operator[](size_t index) const;. Returns a read-only reference when the container is accessed through a const reference or const object instance.

Omitting the const overload makes the container unusable inside read-only functions (e.g., void inspect(const MyVector& v)), while omitting the non-const overload prevents element mutation.

02Smart Pointer Indirection: operator* and operator->

Smart pointers (like std::unique_ptr or custom memory wrappers) must mimic the syntax of raw pointers. This requires overloading the dereference operator (*) and the member access arrow operator (->).

The dereference operator returns a reference to the pointed-to object: T& operator*() const noexcept { return *ptr_; }.

The arrow operator returns a raw pointer to the object: T* operator->() const noexcept { return ptr_; }.

03The Recursive Drill-Down Behavior of operator->

The arrow operator (->) possesses a unique syntactic property in the C++ language grammar: it applies recursively.

When the compiler parses sp->method(), it checks what sp.operator->() returns. If it returns a raw pointer (T*), the compiler accesses the member: (sp.operator->())->method().

However, if operator-> returns ANOTHER object that also overloads operator->, the compiler continues drilling down recursively until it finally reaches a raw pointer! This unique behavior enables proxy patterns, thread-safe synchronized wrappers, and lazy-loading ORM objects.

04Indirection Operators Summary

Summary of operator signatures for container access and smart pointer indirection:

Providing const correctness across both indexing and dereferencing is essential for production API design.

+----------------------+--------------------------+-----------------------+| Operator             | Signature                | Typical Role          |+----------------------+--------------------------+-----------------------+| operator[] (mutable) | T& operator[](size_t)    | Array element write   || operator[] (const)   | const T& operator[](sz)  | Array element read    || operator*            | T& operator*() const     | Object dereferencing  || operator->           | T* operator->() const    | Member access proxy   |+----------------------+--------------------------+-----------------------+

05Production Systems Architecture & Hardware Trade-Offs

From an operating system and hardware architecture perspective, systems software must account for physical execution realities that compiler abstractions intentionally hide. At the hardware level, instruction caches (I-Cache) and data caches (D-Cache) operate independently, and CPU pipeline front-ends rely heavily on branch target buffers (BTB) to minimize instruction fetch stalls. When code is organized into coherent, spatially contiguous blocks within translation units, binary code density increases, improving instruction cache hit rates across high-frequency execution loops.

Furthermore, modern linkers such as LLVM lld and mold perform Link-Time Optimization (LTO) across translation units. When LTO is enabled (-flto), the compiler writes LLVM bitcode into object files rather than final machine code, allowing the linker to perform cross-translation-unit function inlining, devirtualization, and dead-code stripping across the entire binary.