If we have a class like this:
Can define a function that can cast an object of the class myClass to a char *, so that if we canm write the following:Code:class myClass{ public: myClass(); ~myClass(); private: char *myString; };
If I can do this, can you tell me how?Code:myClass object1; cout << object1; //so this makes the casting.
Thanks is advance.
That's not really casting. You're just wanting to be able to cout your object's string with just the object - correct?
Code:class myClass{ public: myClass() : public_str(myString){ /* */ } ~myClass(); const char *public_str; friend ostream& operator << ( ostream& stream, myClass& object ){ stream << object.public_str; return stream; } private: char *myString; };
Code:#include <cmath> #include <complex> bool euler_flip(bool value) { return std::pow ( std::complex<float>(std::exp(1.0)), std::complex<float>(0, 1) * std::complex<float>(std::atan(1.0) *(1 << (value + 2))) ).real() < 0; }
Hi, thanks for the reply, but what I meant was not overloading the << operator.
I wanted to now if there is another way to do cout << object;
for example like casting, because I read that casting can do the same job of overloading if we want to output the strings in an object.
Does anybody have any idea about this?
Can we overload the casting operator?
Yeh you can cast the object to an array of characters if you like.
You could do something like:
char* bytes = (char*)object1;
In this case you should also use sizeof(object) to get the number of bytes of your object, because your char* will not be null terminated and cannot be treated as a string.
HOWEVER, are you sure you want to do this? If there are pointers in you object, you are only going to stream the value of the pointers, and not the content of what they point to. If you want to store values of data members in your object, then there will be better ways to do this.
I think you are hinting at an implicit conversion
Its not preferable to Seb's method mind you.....implicit conversions can cause lots of ambiugity problems and unwanted conversions.......that's why std::string insists on you using the c_str() member.....those guys knew the problems of implicit conversion, so they avoided overloading operator const char*()Code:#include <iostream> class myClass{ public: myClass(const char *String):myString(String){} operator const char*(){return myString;} private: const char *myString; }; int main(void) { myClass object1("Hello World"); std::cout << object1; }
I have never encountered any serious problems with implicit casting (aside from some template confusion). I think it's superior to overloading cout, personally. Which problems are you referring to Fordy?
Code:#include <cmath> #include <complex> bool euler_flip(bool value) { return std::pow ( std::complex<float>(std::exp(1.0)), std::complex<float>(0, 1) * std::complex<float>(std::atan(1.0) *(1 << (value + 2))) ).real() < 0; }
Its because when you decide to implicitly cast, you are giving the compiler the opportunity to cast wherever it can even if the situation is not what you want......it can lead to small errors becoming big ones.....Originally posted by Sebastiani
I have never encountered any serious problems with implicit casting (aside from some template confusion). I think it's superior to overloading cout, personally. Which problems are you referring to Fordy?
Say for instance, you want to add to my above class and add operator+() to concatanate string.....all very well..
std::cout << obj1 + obj2;//great
..but what if you make a small mistake and do this
std::cout << obj1 - obj2;//woops '-' not '+'
Now it should not compile.....but it does, because subtracting 2 pointers is ok.......even if for your object is gives completely the wrong result. So by allowing the conversion, you must take all responsibility for the possible conversions the compiler may see fit to make - not very realistic......so that's why it is advised to avoid implicit conversion and that's why in libraries like the std library, its avoided where it might be easilly abused (as in std::string)
It's discussed in More Effective C++ by Scott Meyers and in Exceptional C++ by Herb Sutter (the latter is where I pinched the above example BTW)
Thank you all, you made the idea clear.
