Question

I often use references to simplify the appearance of code:

vec3f& vertex = _vertices[index];

// Calculate the vertex position
vertex[0] = startx + col * colWidth;
vertex[1] = starty + row * rowWidth;
vertex[2] = 0.0f;

Will compilers recognize and optimize this so it is essentially the following?

_vertices[index][0] = startx + col * colWidth;
_vertices[index][1] = starty + row * rowWidth;
_vertices[index][2] = 0.0f;

Answer 1

Yes. This is a basic optimization that any modern (and even ancient) compilers will make.

In fact, I don’t think it’s really accurate to call that you’ve written an optimisation, since the move straightforward way to translate that to assembly involves a store to the _vertex address, plus index, plus {0,1,2} (multiplied by the appropriate sizes for things, of course).

In general though, modern compilers are amazing. Almost any optimization you can think of will be implemented. You should always write your code in a way that emphasizes readability unless you know that one way has significant performance benefits for your code.

As a simple example, code like this:

int func() {
    int x;
    int y;
    int z;
    int a;

    x = 5*5;
    y = x;
    z = y;
    a = 100 * 100 * 100* 100;

    return z;
}

Will be optimized to this:

int func() {
    return 25
}

Additionally, the compiler will also inline the function so that no call is actually made. Instead, everywhere ‘func()’ appears will just be replaced with ’25’.

This is just a simple example. There are many more complex optimizations a modern compiler implements.