What is the difference between adding these strings? - c++

Question

Program 1:
#include <iostream>
using namespace std;
int main() {
string str;
char temp = 'a';
str += temp + "bc";
cout << str;
return 0;
}
Output:
Unknown characters
Program 2:
#include <iostream>
using namespace std;
int main() {
string str;
char temp = 'a';
str += temp;
str += "bc";
cout << str;
return 0;
}
Output:
abc
Why are both the outputs different? Shouldn't both outputs be the same?

Answer 1

This statement
str += temp + "bc";
can be represented like
str = str + ( temp + "bc" );
In the sub-expression temp + "bc" the string literal "bc" is implicitly converted to pointer to its first character and has the type const char *. The value of the variable temp is converted to the type integer due to the integer promotions that for example in ASCII table has the value 97.
So in the sub-expression there is used the pointer arithmetic. The expression temp + "bc" points to a memory that outside the string literal. So the result of the expression is undefined.
If you would write for example
char temp = 1;
then the expression temp + "bc" points to the second character of the string literal. As a result str would have the value 'b'.
Or to get the same result as in the second program you could write
str += temp + std::string( "bc" );
As for the second program then in this statement
str += temp;
str += "bc";
there are used overloaded operators += for the class std::string and objects of type char and char *. So these statements are well-defined.
Pat attention to that you should include explicitly the header <string>.
#include <string>

Answer 2

Program 1 in this line
str += temp + "bc";
first arguments of addition are evaluated
on right there is array of char: const char[3]
on left there is char which can be auto converted to int
const char[3] degrades to const char *
adding int (97) and const char * is doable, but results points beyond buffer range.
then you are using basic_string::operator+=( const CharT* s );, but argument is invalid. You have got buffer overflow.
Program 2.
Doesn't have this undefined behavior and operators form std::string are used.
Another reasonable version is:
str = str + temp + "bc";
Now each addition will create a std::string as a result.

Answer 3

std::string class has + and += operators overloaded, allowing you to use those to concatenate std::strings with each other, with individual characters and arrays of characters.
But just like in C, "bc" is not a std::string but a const char [3] (a constant array of 3 characters). Arrays are often automatically converted (decay) to pointers to their first elements. It happens here too.
str += "foobar"; appends the characters pointed by the pointer one by one, until it hits the null byte that terminates the string.
You can add integers to pointers: str += "foobar" + 3; will append "bar" to the string.
In C++, chars are simply small integers. So 'a' + "bc" actually means 97 + "bs" (assuming your compiler uses ASCII, all common ones do).
This forms a pointer that's out of bounds of the array and causes undefined behavior.
The random characters you're seeing are the contents of memory located 97 bytes after the "bc" array, terminated by a random null byte that was in that memory.