operator char*() not working?

Hi All,
I'm playing with a custom string class.

//////////////////////////////////// in mystring.h
class mystring {
char* p;
public:
mystring(): p(0) {}
mystring(char*);
~mystring();
operator char*() { return p; } // operator char*() defined here

friend ostream& operator<< (ostream&, const mystring&);
};

//////////////////////////////////// in mystring.cpp
ostream& operator<< (ostream& os, const mystring& str)
{
os << (char*)str; // ERROR REPORTED HERE – compiler can't find operator char*()
return os;
}

//////////////////////////////////// in main.cpp
void main()
{
mystring hello = "Hello World!";
cout <<hello;
}

I get the following:
error C2440: 'type cast' : cannot convert from 'const class mystring' to 'char *'
No user-defined-conversion operator available that can perform this conversion, or the operator cannot be called

WHAT? Operator char*() is defined right there! What am I doing wrong?

Note the const in your compiler's error message and modify your operator so that it is a const function.

First: you have to reserve memory for p:

I hope you do that in mystring(char */*put variable- it's more clear*/);

And do that mystring(): p("") {}

Second: i think that code does not make sense. I mean it would be usefull if you convert this char * to integer, but I don't know, as you wish. And I'm not sure whether you can overload char*(at least I haven't seen it before) but I will search about this.

Code:

---

class mystring
{
        char* p;

public:
        // You two constructors can be combined into one by
        // using default value.
        mystring(char* s=0): p(s) {}
        ~mystring();

        // There is no need for this typecast operator in your
        // example. However, if you want to use it in operator<<,
        // you need to declare it as a constant function.
        operator char*() const{ return p; }

        friend ostream& operator<< (ostream&, const mystring&);
};

ostream& operator<< (ostream& os, const mystring& str)
{
        // Since this is a friend function, you can use the member
        // variable of mystring directly. There isn't any need
        // to declare and implement a "operator char*()".
        os << str.p;
        return os;

        // Alternative, if you like to do typecasting.
        //os << static_cast<char*>(str);
        //return os;
}

---

Well, yes you can and what Kheun has done is working. Look it!

operator char*() const

That was it! Thanks very much all!

Of course, that could lead to all sorts of problems... the best thing to do with user-defined conversions is to forget them. Do it explicitly, with a named function and you won't get hard-to-find bugs as the compiler puts in an implicit conversion that you don't notice and don't want.

If you still want to do implicit conversions, I would suggest that you provide these two:

Code:

---

class mystring
{
public:
    operator const char * () const;
    operator char * ();  // optional (and not recommended)
};

ostream& operator<<(ostream& os, const mystring& s)
{
    return os << static_cast<const char *>(s);
}

---

However, a better solution would be:

Code:

---

class mystring
{
public:
    const char * c_str() const;
    char* c_str();  // optional (and not recommended)
};

ostream& operator<<(ostream& os, const mystring& s)
{
    return os << s.c_str();
}

---

I've marked the two non-const functions as "not recommended" because they expose the internals of your class and, again, can lead to hard-to-find bugs when something modifies your data member without you knowing about it.

Thanks Graham! I found this to work (it returns a const char* so anyone using the class cannot modify *p)

operator const char*() const