[Dev-C++] Re: Operator overloading for built in types

[Kevin B. <tec...@ne...>]

Operators may not be overloaded for built-in types, for reasons that are 
fairly clear if you pause to consider the implications.

In this case, you are attempting to fundamentally change the meaning of the 
expression. You might think of char* as a "string", but C++ thinks of it as 
a pointer. s1 == s2 compares the address values contained in the pointer 
itself, not the strings they point to. You are asking it for a radical 
change in behavior. Consider the potential for mischief allowing this sort 
of thing would cause. C++ already has enough minefields. The whole point of 
operator overloading is to make the resulting code more clear in its 
intent. Your attempt not only obfuscates the resulting code, since you are 
actually attempting to compare not the pointers but the null-terminated 
char arrays they reference, and furthermore lays a booby-trap for anybody 
hoping to maintain the code thereafter who foolishly assumes they can tell 
if two variables are pointing to the same location by using the == operator.

And so, such things are illegal. It is allowed for custom types, since 
there are no preexisting assumptions about how such types should behave as 
there would be with, say, int or bool. Even so, operator overloading used 
to excess can quickly make code practically unmaintainable.

You need to use a string class with the (char *) and == operators 
overloaded in the way you desire. The standard library already provides 
such a class, std::String.  You can do exactly what you want with no 
further coding required like so: String( s1) == String( s2 ). Of course, 
using String to hold your strings in the first place would eliminate a lot 
of temporaries. I question what you would be accomplishing by the foregoing 
maneuver.

Or, you could make your own lightweight struct with the necessary operators 
and constructors. But honestly, if you can't or don't want to use 
std::String from the start, is reading strcmp really so bad? Why confuse 
the situation and introduce potential bugs and maintenance headaches just 
so you can use == and save a few keystrokes? If the use of a real string 
class is unpalatable, I strongly suggest sticking with the strcmp method, 
since anybody reading it will most certainly understand what is going on, 
whereas your attempts at operator magic will likely just confuse the 
situation. Refactor when it produces a measurable benefit, not just because 
you can. If you must refactor this code, refactor to use std::String 
instead of char* altogether, rather than just worrying about the compare 
operation.

--- Kevin