C ++字符串联与std :: string行为。 请解释一下

Question

Here are some cases about c++ std::string which I couldn't understand.

1.

string ans = ""+'a';
cout << ans << endl; //Prints _string::copy

2.

string ans="";
ans=ans+'a';
cout << ans << endl; //Prints a

3.

string ans="";
ans = ans + (5 + '0'); // Throws error

4.

string ans="";
ans += (5 + '0'); //works

5.

In a code, I had the line ans += to_string(q); q was a single digit integer. The program threw runtime error.

Changed it to ans+= (q+'0'); and the error got removed.

Please help with clearing the idea.

Answer 1

string ans = ""+'a';

"" is an address of an empty string literal. 'a' gets interpreted as an integer, ASCII code 65. This adds 65 to an address of a literal string, which results in undefined behavior, possibly a crash.

ans=ans+'a';

ans is a std::string . std::string defines an overloaded + operator. Several, actually. One of them, in particular, overloads + where the parameter is a character, and it appends the character to the string.

ans = ans + (5 + '0'); // Throws error

5+'0' is an expression that's promoted to an int type. std::string does not unambiguously overload the + operator with an int as the parameter. This result in a compilation error.

ans += (5 + '0'); //works

std::string does have an unambigous overloaded += operator, so this compiles fine.

Answer 2

This:

std::string ans = ""+'a';

is not what you think, you actually perform the same operation as below:

const char* p = "";
p = p + 97 /*97=='a'*/; // increase p pointer by `a` value, results in UB (pointer to random memory)
std::string ans = p; // p points to possibly unallocated memory (UB).

which makes little sense.

if you compile it with clang you will get long list of warnigns:

main.cpp:22:25: warning: adding 'char' to a string does not append to the string [-Wstring-plus-int]
    std::string ans = ""+'a';
                      ~~^~~~
main.cpp:22:25: note: use array indexing to silence this warning
    std::string ans = ""+'a';
                        ^
                      & [   ]
main.cpp:22:25: warning: adding 'char' to a string pointer does not append to the string [-Wstring-plus-char]
    std::string ans = ""+'a';
                      ~~^~~~
main.cpp:22:25: note: use array indexing to silence this warning
    std::string ans = ""+'a';
                        ^
                      & [   ]

Answer 3

String literal is an array of characters. It it not an instance of std::string . Arrays cannot be passed to functions or operators by value, but instead they decay to a pointer to first character, when used an operand.

Characters are numbers that encode symbols. All characters have a non-zero value, except for '\\0' .

In the expression ""+'a' , the string literal decays to pointer, then 'a' character is iterpreted as a non-zero integer. This value is added to the pointer. Regardless of the value of a (It happens to be 65 in the commonly used ASCII encoding), the result is beyond the bounds of the array. Pointer arithmetic out of bounds has undefined behaviour, and the output 1. is the result of the undefined behaviour.

---

The program 2. has well defined and expected behaviour.

---

 ans = ans + (5 + '0'); // Throws error 

There is no operator+ that accepts arguments std::string and int . The right hand argument is int because the char argument in 5 + '0' is promoted to int so that both arguments are of same type. This is also the return type of the expression.

This is where it gets hairy. There is an operator+ that accepts char and int is convertible to char . However, there are also other possible conversions that are ambiguous. Here is the error shown by clang:

error: invalid operands to binary expression ('string' (aka 'basic_string<char>') and 'int')

    ans = ans + (5 + '0'); // Throws error

          ~~~ ^ ~~~~~~~~~

./include/c++/6.1.0/bits/basic_string.h:4982:5: note: candidate template ignored: deduced conflicting types for parameter '_CharT' ('char' vs. 'int')

    operator+(const basic_string<_CharT, _Traits, _Alloc>& __lhs, _CharT __rhs)

    ^

./include/c++/6.1.0/bits/basic_string.h:5036:5: note: candidate template ignored: deduced conflicting types for parameter '_CharT' ('char' vs. 'int')

    operator+(basic_string<_CharT, _Traits, _Alloc>&& __lhs,
^

... And many other potential overloads.

---

 ans += (5 + '0'); //works 

This works because operator+=(char); is an unambiguous overload.

---

In a code, I had the line ans += to_string(q); q was a single digit integer. The program threw runtime error.

Works fine here, no errors thrown.