C++ optimization of reference-to-pointer argument

Question

I'm wondering with functions like the following, whether to use a temporary variable (p):

void parse_foo(const char*& p_in_out,
               foo& out) {
    const char* p = p_in_out;

    /* Parse, p gets incremented etc. */

    p_in_out = p;
}

or can I just use the original argument and expect it to be optimized similarly to the above anyway? It seems like there should be such an optimization, but I've seen the above done in a few places such as Mozilla's code, with vague comments about "avoiding aliasing".

Answer 1

The variant with a temporary variable could be faster since it doesn't imply that every change to the pointer is reflected back to the argument and the compiler has better chances on generating faster code. However the right way to test this is to compile and look at the disassembly.

Meanwhile this has noting to do with avoiding aliasing. In fact, the variant with a temporary variant does employ aliasing - now you have two pointers into the same array and that's exactly what aliasing is.

Answer 2

I would use a temporary if there is a possibility that the function is transactional.

i.e. the function succeeds or fails completely (no middle ground).
In this case I would use a temp to maintain state while the function executes and only assign back to the in_out parameter when the function completes successfully.

If the function exits prematurely (ie via exception) then we have two situations:

• With a temporary (the external pointer is unchanged)
• Using the parameter directly the external state is modified to reflect position.

I don't see any optimization advantages to either method.

Answer 3

One thought that comes immediately in mind: exception safety. If you throw an exception during parsing, the use of a temporary variable is what you should do to provide strong exception safety: Either the function call succeeded completely or it didn't do anything (from a user's perspective).

Answer 4

All good answers, but if you're worried about performance optimization, the actual parsing is going to take nearly all of the time, so pointer aliasing will probably be "in the noise".

Answer 5

How does the compiler know that p_in_out isn't aliased somehow? It really can't optimize away writing the data back through the reference.

struct foo {
    setX(int); setY(int); 
    const char* current_pos;
} x;
parse_foo(x.current_pos, x);

---

I look at this and ask why you didn't just return the pointer Then you don't have a reference to a pointer and you don't have to worry about modify the original.

const char* parse_foo(const char* p, foo& out) {
    //use p;
    return p;
}

It also means you can call the function with an rvalue:

p = parse_foo(p+2, out);