Int to String in C++ – How to Convert an Integer with to_string

As a C++ developer, you often need to convert between different data types in your code. One common scenario is converting numerical values like integers and floating point numbers to their string representations. This is necessary for tasks like printing out numbers, concatenating them with other strings, or saving them to a file or database.

Traditionally, converting numbers to strings in C++ required using somewhat clunky techniques like stringstreams or the sprintf function. However, since the C++11 standard, a more convenient option is available: the std::to_string function. In this article, we‘ll take an in-depth look at how to use to_string to easily convert integers and other number types to strings in C++.

What is std::to_string?

std::to_string is a simple and intuitive way to convert a number to its string representation in C++. It‘s part of the header and takes a single number as input, returning the equivalent string.

The to_string function is overloaded to work with a variety of number types, including:

• int
• unsigned int
• long
• unsigned long
• long long
• unsigned long long
• float
• double
• long double

This covers pretty much any numerical type you‘re likely to encounter in C++. Being able to convert all these to strings with a single, easy to remember function is a big improvement over legacy approaches.

One important thing to note is that to_string is only available in C++11 and later. If you‘re using an older version of C++, you‘ll need to stick with something like stringstream instead (more on that later).

to_string syntax and example usage

The syntax for std::to_string is straightforward. You simply pass the number you want to convert as the argument. Here are a few examples:

#include <string>
#include <iostream>

int main() {
  int myInt = 42;
  std::string myString = std::to_string(myInt);
  std::cout << myString << std::endl; // prints "42"

  double myDouble = 3.14159;
  std::string myDoubleString = std::to_string(myDouble);  
  std::cout << myDoubleString << std::endl; // prints "3.14159"

  bool myBool = true;
  std::string myBoolString = std::to_string(myBool);
  std::cout << myBoolString << std::endl; // prints "1"
}

As you can see, we‘re able to easily convert int, double, and even bool types to their string equivalents by passing them to to_string. The string returned by to_string can then be printed out, concatenated with other strings, or manipulated in any other way you‘d normally use a string.

One handy use case is building up a string from multiple parts:

int age = 25;
std::string name = "John";
std::string message = name + " is " + std::to_string(age) + " years old.";
std::cout << message << std::endl; // prints "John is 25 years old."

Here we use to_string to convert the integer age to a string, allowing it to be concatenated with the other strings to form a complete sentence. Without to_string, the concatenation would fail since you can‘t concatenate strings with integers directly.

Performance considerations and alternatives

While std::to_string is convenient, it‘s not always the best choice from a performance perspective. Under the hood, to_string has to perform a relatively expensive conversion from the number‘s binary representation to a sequence of character digits. For small numbers and infrequent conversions this is usually not an issue. However, if you‘re working with very large numbers or doing frequent conversions in performance-critical code, the costs can add up.

In situations where performance is paramount, you can often get better results using lower-level techniques like sprintf or hand-rolling your own integer to string conversion. These approaches avoid the overhead and indirection of to_string at the cost of being more complex to implement and maintain.

For most common use cases, however, to_string offers a good balance of convenience and performance. Just be sure to profile and measure before making assumptions about which approach will be faster for your specific scenario.

If you‘re working with code that needs to run on older versions of C++ (prior to C++11), you can fall back to using a stringstream for number to string conversions:

#include <sstream>
#include <string>

int main() {
  int num = 42;
  std::stringstream ss;
  ss << num;
  std::string numString = ss.str();
}  

This is a bit more verbose than to_string but gets the job done. You could also use sprintf as an alternative:

#include <cstdio>

int main() {
  int num = 42;
  char buffer[20];
  std::sprintf(buffer, "%d", num);
  std::string numString(buffer);
}

Again, a bit clunkier than to_string but viable for pre-C++11 code. It‘s worth noting that sprintf requires you to ensure the buffer you pass is large enough to hold the resulting string. This makes it more error prone than to_string or stringstream which handle memory management for you.

Limitations of to_string

While to_string is a convenient and flexible way to convert numbers to strings, it does have a few limitations to be aware of.

First, as mentioned earlier, it‘s only available in C++11 and later. If you need your code to compile with older C++ standards you‘ll need to use an alternate approach.

Second, to_string provides no facility for controlling the precision or formatting of the resulting string. With floating point values in particular, you may want to specify the number of digits shown after the decimal point. printf-style functions allow this by letting you provide a format specifier, but to_string always uses the default precision. If you need finer control over the string format, printf or std::format (in C++20) may be a better choice.

Finally, be aware that to_string has some interesting behavior around very large numbers. With integer types, to_string will happily convert numbers up to the maximum (and minimum) supported values. However, with floating point numbers, values above (or below) a certain threshold may be converted to scientific notation or rounded in ways you might not expect. If you‘re working with very large or very precise floating point numbers, be sure to verify to_string is giving you the results you expect. For the most precise control, consider using sprintf or another function that allows you to fully specify the output format.

Real-world examples

To help solidify your understanding of std::to_string, let‘s walk through a few examples of where it might be useful in real code.

One common scenario is logging or printing out diagnostic info:

int errorCode = 42;
std::string errorMessage = "Something went wrong! Error code: " + std::to_string(errorCode);
logError(errorMessage);

Here we use to_string to convert the error code integer to a string so it can be concatenated with the error message. This allows us to output a more informative message for debugging purposes.

Another potential use case is building up a JSON or XML string:

int userId = 12345;
std::string name = "John Smith";
int age = 42;

std::string jsonString = "{\"userId\": " + std::to_string(userId) + 
                         ", \"name\": \"" + name + "\"" +
                         ", \"age\": " + std::to_string(age) + "}";

In this example, we‘re using to_string to convert the integer userId and age to strings. This allows them to be inserted into the JSON string we‘re constructing. Without to_string we wouldn‘t be able to include the integer values in the JSON since JSON strings can only contain other strings, not direct integer values.

One more example, this time converting a floating point number:

double price = 19.99;
std::string displayPrice = "$" + std::to_string(price);
showProductPrice(displayPrice);

Here we‘re using to_string to convert the floating point price to a string. We then concatenate it with a "$" character to format it as a price for display to the user. Again, to_string makes this simple and avoids having to manually specify format specifiers as we would with sprintf.

Conclusion

In this article we‘ve taken a deep dive into the std::to_string function and how it can be used to convert integers and other numbers to strings in C++. We‘ve looked at the basic syntax and walked through a number of examples. We‘ve also discussed some of the performance considerations and limitations to be aware of when using to_string.

To summarize, std::to_string offers a convenient and flexible way to convert numbers to strings in modern C++ code. It‘s straightforward to use and avoids the need to manually manage buffers or format strings. However, it may not be the best choice in all situations – particularly very high performance code or cases where you need fine-grained control over the output string format.

At the end of the day, std::to_string is a useful tool to have in your C++ toolbox. It can help make your code cleaner and more concise in many common scenarios. Just be sure to understand its limitations and when you might need to reach for printf, stringstream, or other alternatives instead. Happy coding!