Consider this:
std::string str = "Hello " + "world"; // bad!
Both the rhs and the lhs for operator + are char*s. There is no definition of operator + that takes two char*s (in fact, the language doesn’t permit you to write one). As a result, on my compiler this produces a “cannot add two pointers” error (yours apparently phrases things in terms of arrays, but it’s the same problem).
Now consider this:
std::string str = "Hello " + std::string("world"); // ok
There is a definition of operator + that takes a const char* as the lhs and a std::string as the rhs, so now everyone is happy.
You can extend this to as long a concatenation chain as you like. It can get messy, though. For example:
std::string str = "Hello " + "there " + std::string("world"); // no good!
This doesn’t work because you are trying to + two char*s before the lhs has been converted to std::string. But this is fine:
std::string str = std::string("Hello ") + "there " + "world"; // ok
Because once you’ve converted to std::string, you can + as many additional char*s as you want.
If that’s still confusing, it may help to add some brackets to highlight the associativity rules and then replace the variable names with their types:
((std::string("Hello ") + "there ") + "world");
((string + char*) + char*)
The first step is to call string operator+(string, char*), which is defined in the standard library. Replacing those two operands with their result gives:
((string) + char*)
Which is exactly what we just did, and which is still legal. But try the same thing with:
((char* + char*) + string)
And you’re stuck, because the first operation tries to add two char*s.
Moral of the story: If you want to be sure a concatenation chain will work, just make sure one of the first two arguments is explicitly of type std::string.