Why don't C++ compilers define operator== and operator!=?

Question

I am a big fan of letting the compiler do as much work for you as possible. When writing a simple class the compiler can give you the following for 'free': - A default (empty) constructor - A copy constructor - A destructor - An assignment operator (`operator=`) But it cannot seem to give you any comparison operators - such as `operator==` or `operator!=`. For example: class foo { public: std::string str_; int n_; }; foo f1; // Works foo f2(f1); // Works foo f3; f3 = f2; // Works if (f3 == f2) // Fails { } if (f3 != f2) // Fails { } Is there a good reason for this? Why would performing a member-by-member comparison be a problem? Obviously if the class allocates memory then you'd want to be careful, but for a simple class surely the compiler could do this for you?

Answer 1

You're right, the compiler is capable of producing these three basic items for free, but there's a limit to how well the work. The compiler "does it's best" to initialize the member variables and clean up when the object goes out of scope. And it tries very hard to copy everything when doing an assign, and truth for simple classes this works fine. But as you scale up your class definitions, it starts to get shaky - add a simple pointer to the mix and this house of cards falls right down.

Good coding practices says you should always define these three, never let the compiler provide what is referred to as a "shallow" method. Do otherwise can lead to undefined results.

When we start to talk about comparison, however, it begs the question -- just what exactly determines that two objects of the same class are equal? Do you honestly want it comparing each and every member by default, when all that really needs to be checked is the ID? Let's not even discuss if the class has pointers.