[shafiq.chaudhry.cs]

bool myString::operator == ( const myString &r )
{
    if ( size != r.size )
    {
        return false;
    }
    for ( int i = 0; i < size; i ++ )
    {
        if ( str [i] != r.str [i] )
        {
            return false;
        }
    }
    return true;
}


bool myString::operator != ( const myString &r )
{
    return ! ( this == &r );
}

int main ()
{
    myString s1 ( "Happy" ), s2 ( " Birthday" ), s3 ( " to you Shafiq" ), s4, s5 ( "Happy" );

    if ( s1 != s2 )
    {
        cout << s1.getStr () << " is not equal to " << s2.getStr () << endl;
    }
    else
    {
        cout << s1.getStr () << " is equal to " << s2.getStr () << endl;
    }

    if ( s1 != s5 )
    {
        cout << s1.getStr () << " is not equal to " << s5.getStr () << endl;
    }
    else
    {
        cout << s1.getStr () << " is  equal to " << s5.getStr () << endl;
    }

    return 0;
}

The above program outputs like this ..

Happy is not equal to Birthday
Happy is not equal to Happy

Now If I just change the following peace of code

bool myString::operator != ( const myString &r )
{
    return ! ( *this == r );
}

Results are shown as..

Happy is not equal to Birthday
Happy is equal to Happy


Why it happens, is there any difference between calling ( this == &rightObject ) and ( *this == rightObject ) ... of course there is a difference of syntax by is any difference semantically. Please tell thanks

[Oler1s]

So..., what are the following:

- this
- &rightObject
- *this
- rightObject.

[shafiq.chaudhry.cs]

hmmm I got the answer, I was comparing the addresses of two objects in
1 bool myString::operator != ( const myString &r )
2 {
3 return ! ( this == &r );
4 }

and definitely both objects are having different addresses in the memory space.

I must use this one ...

1	bool myString::operator != ( const myString &r )
2	{
3	    return ! ( *this == r );
4	}

[baavgai]

When in doubt, test.

Here's a quick program:

#include<iostream>

using namespace std;

class Foo {
private:
	int n;
public:
	Foo(int _n) : n(_n) { }
	void showCompare(const Foo &other) {
		cout << "this: "; print();
		cout << "other: "; other.print();
		cout << "this==&other: " << (this==&other) << endl;
		cout << "*this==other: " << (*this==other) << endl;
		cout << endl;
	}
	bool operator==(const Foo &other) const { cout << "oper called" << endl; return n==other.n; }
	void print() const { cout << "Foo(" << n << ") @" << (unsigned long)this << endl; }
};


int main() {
	Foo x(1), y(2), z(1);
	x.showCompare(x);
	x.showCompare(y);
	x.showCompare(z);
	return 0;
}

Results:

this: Foo(1) @140734662243172
other: Foo(1) @140734662243172
this==&other: 1
oper called
*this==other: 1

this: Foo(1) @140734662243172
other: Foo(2) @140734662243176
this==&other: 0
oper called
*this==other: 0

this: Foo(1) @140734662243172
other: Foo(1) @140734662243180
this==&other: 0
oper called
*this==other: 1

Hope this helps.