Why would I need to explicitly cast number 0 to char before appending it to string using string::operator+?
using namespace std;
int main()
{
string s = "";
s += 65; // no compile error
s += (char)0; // requires explicit cast
//s += 0; // compile error
return 0;
}
Update to clarify: My goal has been to append one byte (containing whatever value, including zero) to an existing array of bytes.
Because s += 0 is ambiguous for the following overloaded operators of +=
string& operator+= ( const char* s );
string& operator+= ( char c );
0 for the first function means a NULL terminated string with first character set to NULL, and for the second function is a single character with value set to 0.
It is because ONLY 0 can be implicitly converted into pointer type. No other integer can implicitly be converted into pointer type. In your case, 0 can be converted into const char* and char both. When it is converted into const char*, it becomes a null pointer.
So there is ambiguity as to which conversion should take place, as there are two overloads of operator+=, for each type of arguments: const char* and char.
But when you use non-zero integer, say 65, it cannot convert into const char*. So the only function it can call is one which takes char as argument, as 65 is converted into char.
The compiler views s += 0; as an ambiguous call. It sees both operator+=(char*) and operator+=(char) as valid calls.
As all the other replies have said, std::string has no way of appending an integer. However, this answer doesn't really address your question, as you append the integer 65 in one line, and this does not cause you an error.
First, this seems like a non-conformity in your C++ implementation; this should not work. But, given that it does, why does appending 0 fail? The reason is that C++ compilers regard the literal 0 as either an integer or the null pointer, depending on context. (C++11 added nullptr and friends to add to alleviate this source of confusion.)
Therefore, when your implementation sees the line
s += 0;
it cannot decide between calling operator+=(char*) and operator+=(char).
Look at the C++ string reference. The following overloads are defined:
string& operator+= ( const string& str );
string& operator+= ( const char* s );
string& operator+= ( char c );
To make C++ understand what you want to do, you need to append something whose type matches one of these signatures..
What everybody told you is that 0 is an int, that the availabe operator+=() takes a char or a char*, that 0 (but no other integers) can be converted to both and so there is an ambiguity.
What everybody forgot to tell you is that the correct idiom isn't a cast but to use a char litteral
s += '\0';
If your goal is to have a string equal to "A", then you should simply do:
string s = "";
s += 65;
In C++, you do not need to put a null character (0 or '\0' or '0' or anything like that) on the end of strings. In fact, you must not do this. This is different from C, where you do often need to think carefully about this.
What is your goal? If you don't want a simple "A" as your string, perhaps you want "A0", in which case you would do string s = "";s += 65;s += '0';return 0;
string represents characters. 0 represents an integer. You must type cast to a char to be compatible.
Note that '0' would be a character, and would not need a cast.
