Question

I’m wondering whether sometimes (depends on the platform or compiler or context in code etc) a reference can be more efficient than a pointer?

Answer 1

Yes, it may. The only way we could say “it can’t” is if there were a requirement (explicit or implied) in the standard that references be as slow or slower than equivalent pointers in all cases. There is no such requirement, since the standard doesn’t concern itself with that kind of performance detail.

For example, at low optimization levels it would be reasonable for this:

int n = 0;
int *np = &n;
for (int i = 0; i < 10000000; ++i) {
    *np += i;
}
std::cout << n;

to be a little slower than this:

int n = 0;
int &nr = n;
for (int i = 0; i < 10000000; ++i) {
    nr += i;
}
std::cout << n;

simply because it’s a little easier in the first case for the compiler to detect that it can avoid the indirection entirely – nr is explicitly an alias for n everywhere it is in scope, whereas *np just so happens to remain an alias for n because we never assign to np after it is initialized. The result with low optimization might well be more indirection in the pointer case and a less efficient loop.

Take a look at the code your compiler emits, though – gcc with no optimization emits the same code for me, it looks to have spotted the alias in both cases and is using a register for the total and a stack slot for i.

Of course you’d expect a good optimizing compiler to “understand” the aliasing in both cases, and emit code that stores n in a register, and only touches that register (not memory) in the loop.