Do C++ compilers optimize pass by const reference POD parameters into pass by copy?

Question

Consider the following:

struct Point {double x; double y;};  double complexComputation(const& Point p1, const Point& p2) {     // p1 and p2 used frequently in computations } 

Do compilers optimize the pass-by-reference into pass-by-copy to prevent frequent dereferencing? In other words convert complexComputation into this:

double complexComputation(const& Point p1, const Point& p2) {     double x1 = p1.x; double x2 = p2.x;     double y1 = p1.y; double y2 = p2.y;     // x1, x2, y1, y2 stored in registers and used frequently in computations } 

Since Point is a POD, there can be no side effect by making a copy behind the caller's back, right?

If that's the case, then I can always just pass POD objects by const reference, no matter how small, and not have to worry about the optimal passing semantics. Right?

EDIT: I'm interested in the GCC compiler in particular. I guess I might have to write some test code and look at the ASM.

Answer 1

Your compiler can absolutely lift Point member variables into registers if needed. This, however, is not the same as the compiler converting the function call itself into pass by value.

You should inspect the generated assembly to see what optimizations are being done.

And FWIW, the general rule I use is to pass all primative types by value and all classes/UDTs (PODs or not) by const reference when I can, and let the compiler sort out the best thing to do. We shouldn't worry ourselves with the details of what the compiler is doing, it is much smarter than us.