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

[Tanaka]

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

#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

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:

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?

[laserlight]

That is because the member function was not declared const. If you want to overload operator+ as a member, then I would expect:

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

Notice the return type is point, not reference to pointer. Notice also the const reference parameter and the const at the end that declares the member function to be const.

Another way is to overload operator+= as a member:

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

then define operator+ as a non-member function in terms of operator+=, e.g.,

point operator+(point left, const point& right)
{
    return left += right;
}

[Paul McKenzie]

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

As laserlight pointed out, your return of a reference is wrong here. Even though you don't get a compile error, returning references to local objects is undefined behaviour. For example:

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

You are creating a local "point" object. Then you're returning a reference to this local object. When the operator+ function returns, that local point object is now gone. You now have a reference to something that no longer exists. You now use it in your program, and who knows what will happen -- maybe your program will "work", maybe it will crash, who knows.

The solution as pointed out is to return a point object, not a reference.

Regards,

Paul McKenzie