Как правильно перегружать операторы?

class Point
{
public:
    Point(int,int,int);
    
private:
    int x;
    int y;
    int z;
};

#include "point.h"
Point::Point(int x,int y,int z)
{
    this->x=x;
    this->y=y;
    this->z=z;
}

    Point p1(0,1,2);
    Point p2(1,2,3);
    Point p3(0,0,0);
    p3=p1+p2;

class Point
{
public:
    Point(int x_, int y_, int z_) :
        x(x_), y(y_), z(z_) {}
 
    Point& operator +=(const Point& rhs)
    {
        x += rhs.x;
        y += rhs.y;
        z += rhs.z;
        return *this;
    }
 
private:
    int x, y, z;
};
 
const Point operator +(const Point& lhs, const Point& rhs)
{
    return Point(lhs) += rhs;
}

 return *this; // потому что возвращается сам изменённый объект

(p1 + p2) = p3;

...Point(lhs)

const Type&operator+(const Type&value)const
{
    Type temp=*this;
    temp+=value;
    return temp;//после этой строчки temp подохло и ссылка ведет в никуда
}

#include <iostream>
#include <string>
///////////////////////////////////////////////////////////////////////////////
typedef std::string     T_str;
///////////////////////////////////////////////////////////////////////////////
class   T_point
{
    //-------------------------------------------------------------------------
    int     x;
    int     y;
    int     z;
    //-------------------------------------------------------------------------
public:
    //-------------------------------------------------------------------------
    T_point (
                int     x_,
                int     y_  =   {},
                int     z_  =   {}
            )
            :
        x(x_),
        y(y_),
        z(z_)
    {}
    //-------------------------------------------------------------------------
    T_point     &   operator +=( T_point    const   &   R )
    {
        x   +=  R.x;
        y   +=  R.y;
        z   +=  R.z;
 
        return  *this;
    }
    //-------------------------------------------------------------------------
    friend
    std::ostream    &   operator<<
        (
            std::ostream            &   ostr,
            T_point         const   &   point
        )
    {
        ostr    <<  '{'
                <<  point.x     <<  ','
                <<  point.y     <<  ','
                <<  point.z
                <<  '}';
 
        return  ostr;
    }
    //-------------------------------------------------------------------------
};
///////////////////////////////////////////////////////////////////////////////
const   T_point     operator+
    (
        const   T_point   &   L,
        const   T_point   &   R
    )
{
    return  T_point(L)  +=  R;
}
///////////////////////////////////////////////////////////////////////////////
int     main()
{
    T_point   q{1, 1, 1};
    std::cout   <<  1 + q   <<  std::endl;
}