Quote:Original post by saeedm
I'm trying to overload the < operator in my class Vertex so that my make_heap function can sort them by their .getDist() value. My problem is I run into errors since my heap actually contains Vertex pointers. How should I overload the < operator, or should I try another approach? The value I need to compare is accessed like this:

Vertex * v;
v->getDist();

Thanks for any help

template <class T>class Vertex {private:    float distance;    T x, y, z;    // other members herepublic:    Vertex(T x, T y, T z);    ~Vertex();    // other class methods here        void SetDistance(float d) { distance = d; } // just for this example      bool operator < (const Vertex<T>& right) {        return this->distance < right.distance;    }};    Vertex<int>* a = new Vertex<int>(1, 2, 3);    Vertex<int>* b = new Vertex<int>(1, 2, 3);    a->SetDistance(10.0f);    b->SetDistance(11.0f);    if(a < b)        std::cout << "Hey" << std::endl;

Quote:Original post by Atom
Since your comparing to classes that are the same, and using a member variable to to determine which Vertex (class) is less then the other Vertex (class), you can just overload the < operator in the class. That way when your do a comparison VertexA < VertexB, it will use the classes < operator. This way you don't have to use your access function for comparisons.

Quote:Original post by jyk
You could try creating a global (free) operator<() function that takes two Vertex pointers as arguments (I'm pretty sure this would work).

struct less_vector_pointer	:	public std::binary_function< Vertex const *, Vertex const *, bool >{	bool operator()(Vertex const * lhs, Vertex const * rhs) const	{		return *lhs < *rhs; // or whatever	}};std::make_heap(vertices.begin(), vertices.end(), less_vector_pointer());

Quote:Original post by Enigma

Quote:Original post by jyk
You could try creating a global (free) operator<() function that takes two Vertex pointers as arguments (I'm pretty sure this would work).

Overloaded operators must have at least one parameter of class type, reference to class type, enumeration type or reference to enumeration type.

Quote:Original post by speciesUnknown
I got so frustrated with operator overloading that I gave up on it and started overloading functions instead, e.g

vector multiply(vector,vector)

vector multiply(vector,matrix)

vector multiply(vector,scalar)

vector multiply(matrix,vector)

vector equals(vector,vector)

its much less headache for all concerned. I know its cowardly.

matrix M = T*R*S;

matrix M = multiply(multiply(T,R),S);