Question

I am trying to understand operators you need to overload when working with custom classes in STL(SCL).

Can any one please tell me what is it I am doing wrong ?

class myClass
{
public:
    int data;
    myClass()
    {
        data =0;
        cout<<"Default const "<<endl;
    }

    myClass(int x)
    {
        data = x;
        cout<<"Int constructor"<<endl;
    }

    myClass(const myClass &m)
    {
        cout<<"Copy constructor"<<endl;
    }

    bool operator == (const myClass &temp)
    {
        cout<<"Operator called &";
        return data == temp.data;
    }

    bool operator == (const myClass *temp)
    {
        cout<<"Operator called *";
        return data == temp->data;
    }
};

int main ()
{
    /*
    vector<int> myvector;
    myvector.push_back(10);
    myvector.push_back(20);
    myvector.push_back(30);

    cout << "myvector contains:";
    for_each (myvector.begin(), myvector.end(), meObj);
    */

    vector<myClass*> myVec;
    myClass temp;
    myVec.push_back(&temp);
    myClass temp2(19);
    myVec.push_back(&temp2);
    myClass temp3(19);

    vector<myClass*>::iterator it = find(myVec.begin(),myVec.end(),&temp2); //works
    if(it!=myVec.end())
    {
        cout<<"Value is "<<(*it)->data;
    }

    vector<myClass*>::iterator dit = find(myVec.begin(),myVec.end(),&temp3); //fails
    if(dit!=myVec.end())
    {
        cout<<"Value is "<<(*dit)->data;
    } 

    cout << endl;

    return 0;
}

Please correct me if I am wrong, but the first find works as it does a address comparison. What do I need to overload for the above to work ?

Do both the signature make sense ?

bool operator == (const myClass &temp); // seen in many places
bool operator == (const myClass *temp); // what if two pointer types of same object are being compared?

Cheers!

Answer 1

Operator overloads must have at least one user-defined type. So you cannot overload operator== for two pointers, for instance.

Your myClass::operator==(const myClass *temp) is valid in the sense that it compiles, but makes very little semantic sense, and is not recommended (there are very few situations where you’d want to do T x; T *y; ... (x == y)).

For your situation, where you have a vector of pointers, you may want to consider std::find_if, which takes a predicate. Something like:

class CompareByPointer
{
public:
    explicit CompareByPointer(const myClass &p) : p(p) {}
    bool operator() (const myClass &rhs) const { return p->data == rhs->data; }
private:
    const myClass &p;
};

...

find_if(myVec.begin(), myVec.end(), CompareByPointer(&temp2));

[As a side note, you should generally define member functions const wherever possible. So your operator overloads should be const.]