Implicit class-type conversions

Ok... As I'm studying classes I'm confronted with this feature:

Quote:

---

A constructor that can be called with a single argument defines an implicit conversion from the parameter type to the class type.

---

While I understand the concept, I have trouble understanding something else... Given the following 3 constructors and member function,

Code:

---

MyClass(const string &str = ""): name(str), value(0) { }
MyClass(istream &is): name(is), value(0) {}
MyClass(const string &str, int val): name(str), value(val) { }

int MyClass::do_something(const myClass &obj) const;

---

I know that only the two first constructors define an implict conversion.
So, if I pass a string to do_something(), the first constructor is used to convert it to a temporary MyClass. Whereas if I pass an istream object, it is the 2nd constructor the one being used to make the implicit conversion.

But why is that I'm being told the istream option is poor class design? Isn't it conceivable that I may want such behavior?

Making things implicit is often poor design because it can surprise the users of your class. If they want to pass a MyClass instance initialized with an istream& to do_something, they can pass MyClass(my_is) explicitly.

BTW, that example doesn't look right. If it is a full class, perhaps the poor design is also related to your name member.

Yes, the class was just an example.

Ok, understood on that. So, is it common for constructors to be declared explicit? Unless I have a strong reason not to, should I do it to avoid the implicit conversion?

Yes, you should declare single parameter constructors as explicit unless you specifically want the implicit conversion and have a good reason to do so.

Ok, Daved. Thanks for that.