Background
I am studying Math related to Game Engines from the book Foundations of Game Engine Development, Volume 1: Mathematics.
The implementation of operator overloads seemed different than the way I would have done it had I not been reading this book and looking at its examples. I wanted to see if the way the author coded it up had performance implications. Searching for the answer to this question was difficult and I could only find other questions about inlining that had nothing to do with comparing these specific styles of declaring operator overloads.
The Example
Vec3.h Version 1
class Vec3
{
public:
float x;
float y;
float z;
Vec3(float x, float y, float z);
inline Vec3 operator+(const Vec3& rval) const
{
return Vec3(this->x+rval.x, this->y+rval.y, this->z+rval.z);
}
};
vs
Vec3.h Version 2
class Vec3
{
public:
float x;
float y;
float z;
Vec3(float x, float y, float z);
};
inline Vec3 operator+(const Vec3& lval, const Vec3& rval)
{
return Vec3(lval.x+rval.x, lval.y+rval.y, lval.z+rval.z);
}
The Question
Version 1 is how I would have implemented the operator+ overload. It seems like the C++ way, making the operator a method of the class.
However, I see throughout the book that the author continues to use version 2 whenever declaring overloads. He declares them outside of the class definition and uses 2 arguments (lval and rval) rather than the implicit this(lval) and right hand argument(rval)
If you try to implement both, understandably there is a compiler error saying it's ambiguous. Which is exactly why I am here to ask this question. To me, it's equivalent and I would rather not have a function sitting in global space, so I would implement version 1.
However, I figured there might be a performance reason for implementing version 2. Maybe inlining is easier for the compiler, or it executes faster for some arcane reason that the author does not mention.
Another idea I had is that perhaps inline is actually functioning more like "static" in this case. I have read elsewhere that inline is pretty much ignored by the compiler anyways because it's going to try to inline it anyway.
When doing
Vec3 v1(1,2,3);
Vec3 v2(1,2,3);
Vec3 v3 = v2-v1;
which performs better? Or, is this just more of a preference thing? Additionally, would it behave differently based on the C++ version? (tagged C++11, 14, and 17 for that reason)
