Overloading Operators Multiple times

Are you trying to create a conversion operator?

For that the syntax would be

operator char*() { return string; }

As John already explained, you cannot base method overload on return value.
That said, the operators

Foothill wrote:

C#

void operator = (cString&);
void operator = (char*);
char * operator = (cString&) const; // <- problem is here

are (at least) not recommended, since they break the language consistency: the assignment operator should return a reference to the object itself (that allows assignment chaining). As a general advice, operator overload is tricky and is usually worhty following well known guidelines (see for instance "C++ Operator Overloading Guidelines"[^], "Assignment operators" at C++ FAQ[^]).

One suggestion: instead of overload assignments, overload constructors: constructors with a single argument are used for implicit conversion.

Assignments are automatically don by a call to an implicit conversion.
Overload them only if you have a more efficient way to handle the assignment respect to the copy.

The only assignment you are required to overload is the one with homogeneous parameter.

class mystring
{
public:
    mystring(); //default
    mystring(const char* literal); // C compatibility
    mystring( .... ); //whatever other conversion
    ~mystring(); //destroy: may by just clear();

    void clear(); //remove content and make it "as per default"
    void swap(mystring& s);  //exchange contents

    mystring(const mystring& src); // copy

    mystring& operator=(mystring src) //the only needed: and should be no more than this: note the copy in the paramenter
    { if(&src != this) { clear(); swap(src); } return *this; }

    /* C++0X only */
    mystring(mystring&& src); //move
    mystring& operator=(mystring&& src) //transfer
    { if(this!=&src) { clear(); swap(src); } return *this; }
};

HI,

As John and Pallini has explained, You can not overload the method depending on its return type.

I mean,
You can overload the method only if both the methods will have either different no of argument or different type of argument.
ex:
int add(int, int);
int add(int, float);
int add(float, int);
int add(float, float); //// these all can be successfully overload

but,
float add(int, int); // it will give you an error.

A small concept called "Name Mangling" is behind all these.
When you write any function definition, The c++ compiler internally changes it to new name
ex: add_ff (ff stands for float float) it means it take two args of type float

now you can see, the return type is not considered while mangling the function names. and hence function can not be overloaded depending on return type.

One more thing I would like mention is, name mangling is compiler dependent and hence the code compiled with Borland compiler won't run with vc++ compiler.

hope it will help you to understand this problem in detail.

thanks,
tushar