## Operator overload not defined error when type is accessed through const struct

I have a basic vector/point class where I've overloaded a bunch of arithmetical operators:

Code:
```#pragma once

class point
{
public:

point()
{

}

point(float p_x, float p_y, float p_z) : x(p_x), y(p_y), z(p_z)
{

}

point& operator+(point& right)
{
return point(x + right.x, y + right.y, z + right.z);
}

point& operator-(point& right)
{
return point(x - right.x, y - right.y, z - right.z);
}

point& operator*(point& right)
{
return point(x * right.x, y * right.y, z * right.z);
}

point& operator*(const float right)
{
return point(x * right, y * right, z * right);
}

point& operator*(const double right)
{
return point(x * right, y * right, z * right);
}

point& operator+=(point& right)
{
return point(x + right.x, y + right.y, z + right.z);
}

point& operator*=(const point& right)
{
return point(x * right.x, y * right.y, z * right.z);
}

point& operator*=(point right)
{
return point(x * right.x, y * right.y, z * right.z);
}

point& operator*=(const float& right)
{
return point(x * right, y * right, z * right);
}

point& operator*=(const double& right)
{
return point(x * right, y * right, z * right);
}

float x;
float y;
float z;
};```
I can use it fine like
Code:
```point p(50,50,50);
point q(50,50,50);
point t = p * q + q;```
However when I put this point type into a struct and try to access the members after passing it through by const reference:
Code:
```struct sextic {
point a,b,c,d,e,f,g;
};

inline static sextic sexticDifference(const sextic &p_sextic1, const sextic &p_sextic2)
{
sextic result;
result.a = p_sextic2.a - p_sextic1.a;
result.b = p_sextic2.b - p_sextic1.b;
result.c = p_sextic2.c - p_sextic1.c;
result.d = p_sextic2.d - p_sextic1.d;
result.e = p_sextic2.e - p_sextic1.e;
result.f = p_sextic2.f - p_sextic1.f;
result.g = p_sextic2.g - p_sextic1.g;

return result;
}```
This gives me an "operator not defined" error for compilation. How do I fix this, please?