在 SAME 结构中使用结构作为 function 的返回类型是常见的做法吗

Question

Its kind hard for me to describe it so here's the code:

#if !defined(OLC_IGNORE_VEC2D)
template <class T>
struct v2d_generic
{
    T x = 0;
    T y = 0;
    inline v2d_generic() : x(0), y(0)                        {                                                            }
    inline v2d_generic(T _x, T _y) : x(_x), y(_y)            {                                                            }
    inline v2d_generic(const v2d_generic& v) : x(v.x), y(v.y){                                                            }
    inline T mag()                                           { return std::sqrt(x * x + y * y);                           }
    inline T mag2()                                          { return x * x + y * y;                                      }
    **inline v2d_generic  norm()                               { T r = 1 / mag(); return v2d_generic(x*r, y*r);             }
    inline v2d_generic  perp()                               { return v2d_generic(-y, x);                                 }
    inline T dot(const v2d_generic& rhs)                     { return this->x * rhs.x + this->y * rhs.y;                  }
    inline T cross(const v2d_generic& rhs)                   { return this->x * rhs.y - this->y * rhs.x;                  }**
    inline v2d_generic  operator +  (const v2d_generic& rhs) const { return v2d_generic(this->x + rhs.x, this->y + rhs.y);}
    inline v2d_generic  operator -  (const v2d_generic& rhs) const { return v2d_generic(this->x - rhs.x, this->y - rhs.y);}
    inline v2d_generic  operator *  (const T& rhs)           const { return v2d_generic(this->x * rhs, this->y * rhs);    }
    inline v2d_generic  operator *  (const v2d_generic& rhs) const { return v2d_generic(this->x * rhs.x, this->y * rhs.y);}
    inline v2d_generic  operator /  (const T& rhs)           const { return v2d_generic(this->x / rhs, this->y / rhs);    }
    inline v2d_generic  operator /  (const v2d_generic& rhs) const { return v2d_generic(this->x / rhs.x, this->y / rhs.y);}
    inline v2d_generic& operator += (const v2d_generic& rhs) { this->x += rhs.x; this->y += rhs.y; return *this;          }
    inline v2d_generic& operator -= (const v2d_generic& rhs) { this->x -= rhs.x; this->y -= rhs.y; return *this;          }
    inline v2d_generic& operator *= (const T& rhs)           { this->x *= rhs; this->y *= rhs; return *this;              }
    inline v2d_generic& operator /= (const T& rhs)           { this->x /= rhs; this->y /= rhs; return *this;              }
    inline operator v2d_generic<int32_t>() const { return { static_cast<int32_t>(this->x), static_cast<int32_t>(this->y) }; }
    inline operator v2d_generic<float>() const { return { static_cast<float>(this->x), static_cast<float>(this->y) };     }
    inline operator v2d_generic<double>() const { return { static_cast<double>(this->x), static_cast<double>(this->y) };  }
};

Is it normal for a function inside a struct to have the return type as the struct itself?:

inline v2d_generic  norm()                               { T r = 1 / mag(); return v2d_generic(x*r, y*r);             }
    inline v2d_generic  perp()                               { return v2d_generic(-y, x);
      

Also I'm kinda confused as to what exactly these lines are doing:

inline v2d_generic  operator +  (const v2d_generic& rhs) const { return v2d_generic(this->x + rhs.x, this->y + rhs.y);}
inline v2d_generic  operator -  (const v2d_generic& rhs) const { return v2d_generic(this->x - rhs.x, this->y - rhs.y);}
inline v2d_generic  operator *  (const T& rhs)           const { return v2d_generic(this->x * rhs, this->y * rhs);    }
inline v2d_generic  operator *  (const v2d_generic& rhs) const { return v2d_generic(this->x * rhs.x, this->y * rhs.y);}
inline v2d_generic  operator /  (const T& rhs)           const { return v2d_generic(this->x / rhs, this->y / rhs);    }
inline v2d_generic  operator /  (const v2d_generic& rhs) const { return v2d_generic(this->x / rhs.x, this->y / rhs.y);}
inline v2d_generic& operator += (const v2d_generic& rhs) { this->x += rhs.x; this->y += rhs.y; return *this;          }
inline v2d_generic& operator -= (const v2d_generic& rhs) { this->x -= rhs.x; this->y -= rhs.y; return *this;          }
inline v2d_generic& operator *= (const T& rhs)           { this->x *= rhs; this->y *= rhs; return *this;              }
inline v2d_generic& operator /= (const T& rhs)           { this->x /= rhs; this->y /= rhs; return *this; 

:)

Answer 1

The functions in question are all overridden operators. These allow c++ to know what happens when you add v2d_generic_1 + v2d_generic_2 for example.

The reason they return a value of type v2d_generic is because that's how the + , - ,etc operators need to work if you want types that behave in a number like way. A + B must return the result of that operator for example so that this result could be then used in the calculation (A + B) * C .

The result of this calculation would also be a v2d_generic and so on..

Answer 2

Is it normal for a function inside a struct to have the return type as the struct itself?:

Yes, it is. In most cases used for operator overloading and generating new instances of struct or class based on current instance of struct or class.

Also I'm kinda confused as to what exactly these lines are doing:

search about operator overloading in c++. cppreference.com operator overloading

Answer 3

The answer is yes, just as it is common to return class instances from class member functions.

The operator lines just simply implement the new operators on the defined type v2d_generic. The same way you can create two strings - stringA and stringB - and concatenate them by using stringA + stringB because the std::string class implements the operator+.

std::string stringA("Hello"), stringB(" StackOverflow"), result;
result = stringA + stringB;

This is possible because std::string implements the operator+.

See here: std::string operator+