Old Wolf wrote:
struct M
{
M(std::string const &s);
}; Totally simplified answer: the standard limits up to 2 implicit
conversions to occur. Variable d looks like const char[6] -> const char
* (this one is a freebie so it doesn't really count) -> std::string ->
M.
So why does the "M a" line compile? That has two conversions:
const char[6] -> std::string -> M.
What I meant by the above deals with where the compiler generates its
own temporaries to do the conversion as opposed to the programmer
explicitly creating an unnamed object along the way.
I guess you saying that the ( ) syntax counts as an explicit
conversion but the = syntax does not, even though they are
both initialization?
Greg's answer in this thread was better than mine since he had it in
terms of user defined conversions and mine was just implicit
conversions while not counting the freebies that occur. But if you're
still confused, here is how the compiler might expand these to (I'm
going to use trailing underscores to note the temporaries the compiler
generates):
M a("Hello");
// becomes:
std::string temp_("Hello");
M a(temp_);
M b = M("Hello");
// becomes:
std::string temp_("Hello");
M temp(temp_);
M b(temp);
M c ( M("Hello") );
// becomes:
std::string temp_("Hello");
M temp(temp_);
M c(temp);
M d = "Hello";
// becomes:
std::string temp_("Hello");
M temp__(temp_);
M d(temp__);
M e = std::string("Hello");
// becomes:
std::string temp("Hello");
M temp_(temp);
M e(temp_);
I hope you can see why d doesn't work but the others do.
