Because in C++, string literals (like "Hello"
are not of type std::string
. They are plain char arrays, or C-style strings.
So for the line const std::string message = "Hello" + ", world" + exclam;
,the types the compiler has to work with are:
const std::string message = const char[6] + const char[8] + std::string;
and given the associativity of +
, the operations it has to perform are:
const std::string message = ((const char[6] + const char[8]) + std::string);
That is, the left-most addition must be evaluated first, and the result passed to the rightmost addition.
So the compiler tries to evaluate const char[6] + const char[8]
.
There is no addition defined for arrays. Arrays are implicitly converted
to pointers, but this doesn't help the compiler. That just means it
ends up with const char* + const char*
, and no addition is defined for pointers either.
At this point, it doesn't know that you want the result to be converted to a std::string
.
However, in your second example:
const
std
::
string hello
=
"Hello"
;
const
std
::
string message
=
hello
+
", world"
+
"!"
;
it works, because the operations the compiler would see were std::string + const char[8] + const char[2]
. Here, the first addition can be converted to std::string + const char*
, and here the addition operator is
defined, and returns a std::string
.
So the compiler has successfully figured out the first addition, and
since the result was a string, the second addition looks like this: std::string + const char[2]
,
and like before, this isn't possible, but the array can be converted to
a pointer, and then the compiler is able to find an addition operator
that works, again resulting in a std::string
.