Original Post
I seem to be having some trouble with objects that are templated and have overloaded operators as being members of another object. For example, I have a 3D point object, that holds the point/particles (X,Y,Z) position. It is templated to support different coordinate storage types (float, double, int). If I want to create a vector between the two points, I subtract the point a from point b and the result is then stored in a vector object, which is also templated. This works fine. Now, let's say I have a triangle object, where the I have points A,B,C. Points A,B, and C are of the point object type mentioned above. When I trying to perform the same subtraction to create a vector between the two points, the compiler generates an error stating that it cannot find a suitable subtraction operator method to handle the situation. So given: This works: But this does not: Any ideas as to why the operators are not working the same when objects are sub objects? [Edited by - Daishim on September 5, 2006 8:40:42 PM]
template<class T_POINT_TYPE>
// 3D point object
struct G_POINT
{
T_POINT_TYPE X;
T_POINT_TYPE Y;
T_POINT_TYPE Z;
G_POINT(void) : X(0), Y(0), Z(0) { /* Empty */ }
G_POINT(const G_POINT<T_POINT_TYPE> &New) : X(New.X), Y(New.Y), Z(New.Z) { /* Empty */ }
G_POINT(const T_POINT_TYPE Init_X, const T_POINT_TYPE Init_Y, const T_POINT_TYPE Init_Z) : X(Init_X), Y(Init_Y), Z(Init_Z) { /* Empty */ }
const G_POINT &operator=(const G_POINT<G_Float> &New) {X = New.X; Y = New.Y; Z = New.Z; return *this;}
const G_POINT &operator-(const G_POINT<G_Float> &Right) {X -= Right.X; Y -= Right.Y; Z -= Right.Z; return *this;}
};
struct G_TRIANGLE
{
G_POINT<G_Float> A;
G_POINT<G_Float> B;
G_POINT<G_Float> C;
};
int func(void)
{
G_POINT Point_A(4.0, 5.0, 6.0);
G_POINT Point_B(1.5, 2.5, 3.5);
G_VECTOR<G_Float> Vector_A = Point_B - Point_A;
}
int func(G_TRIANGLE &Triangle)
{
G_VECTOR<G_Float> Vector = Triangle.B - Triangle.A;
}