Append int to std::string

by

TL;DR operator+= is a class member function in class string, while operator+ is a template function.

The standard class template<typename CharT> basic_string<CharT> has overloaded function basic_string& operator+=(CharT), and string is just basic_string<char>.

As values that fits in a lower type can be automatically cast into that type, in expression s += 2, the 2 is not treated as int, but char instead. It has exactly the same effect as s += '\x02'. A char with ASCII code 2 (STX) is appended, not the character ‘2’ (with ASCII value 50, or 0x32).

However, string does not have an overloaded member function like string operator+(int), s + 2 is not a valid expression, thus throws an error during compilation. (More below)

You can use operator+ function in string in these ways:

s = s + char(2); // or (char)2
s = s + std::string(2);
s = s + std::to_string(2); // C++11 and above only

For people concerned about why 2 isn’t automatically cast to char with operator+,

template <typename CharT>
  basic_string<CharT>
  operator+(const basic_string<CharT>& lhs, CharT rhs);

The above is the prototype[note] for the plus operator in s + 2, and because it’s a template function, it is requiring an implementation of both operator+<char> and operator+<int>, which is conflicting. For details, see Why isn’t automatic downcasting applied to template functions?

Meanwhile, the prototype of operator+= is:

template <typename CharT>
class basic_string{
    basic_string&
      operator+=(CharT _c);
};

You see, no template here (it’s a class member function), so the compiler deduces that type CharT is char from class implementation, and int(2) is automatically cast into char(2).

Note: Unnecessary code is stripped when copying from C++ standard include source. That includes typename 2 and 3 (Traits and Allocator) for template class “basic_string”, and unnecessary underscores, in order to improve readability.

More Related Contents:

  1. What it is the meaning of this error: conversion from ‘char* [40] to non-scalar type ‘std::string
  2. Converting std::string from const_iterator to char*?
  3. How to trim a std::string?
  4. std::string formatting like sprintf
  5. How to replace all occurrences of a character in string?
  6. Legality of COW std::string implementation in C++11
  7. Alternative to itoa() for converting integer to string C++? [duplicate]
  8. Does “&s[0]” point to contiguous characters in a std::string?
  9. How to concatenate a std::string and an int
  10. How do you construct a std::string with an embedded null?
  11. char* vs std::string in c++ [closed]
  12. How do you convert a C++ string to an int? [duplicate]
  13. std::string::c_str() and temporaries
  14. Error: invalid operands of types ‘const char [35]’ and ‘const char [2]’ to binary ‘operator+’
  15. Is std::string ref-counted in GCC 4.x / C++11?
  16. How do you append an int to a string in C++? [duplicate]
  17. How to get the number of characters in a std::string?
  18. Can a std::string contain embedded nulls?
  19. What does string::npos mean in this code?
  20. How do you convert CString and std::string std::wstring to each other?
  21. Why don’t the std::fstream classes take a std::string?
  22. I want to convert std::string into a const wchar_t *
  23. Using the less than comparison operator for strings
  24. convert a char* to std::string
  25. Explicit copy constructor
  26. Padding stl strings in C++
  27. Legal to overwrite std::string’s null terminator?
  28. C++: how to get fprintf results as a std::string w/o sprintf
  29. Concatenating strings doesn’t work as expected [closed]
  30. c++ integer->std::string conversion. Simple function?

Leave a Comment