How to Concatenate a std::string and an int in C++

By the end of this page, you will understand why a std::string cannot be directly concatenated with an int, how to convert numbers into strings in C++, and the most common ways to build combined text such as "John21". You will also see when to use std::to_string versus string streams in real code.

In C++, std::string stores text, while int stores a numeric value. Even though both can be displayed together when printing output, they are still different types.

When you concatenate strings, both sides of the + operator must be string-compatible values. An int is not automatically treated as a string during normal string concatenation, so this does not work:

std::string result = name + age; // error

To combine text and numbers into one string, you must first convert the number into text.

The most common modern way is:

std::string result = name + std::to_string(age);

This matters in real programming because many applications need to build strings dynamically:

• usernames like "john21"
• file names like "report_2024"
• log messages like "Error code: 404"
• API paths like "/users/42"

Whenever text and numbers need to be combined, conversion is required.

Think of std::string as a box that can only hold text labels.

An int is a number object, not a text label. If you want to place the number into the text box, you must first turn it into text.

So instead of trying to mix:

• "John" as text
• 21 as a number

You first convert 21 into "21", then combine:

• "John" + "21" = "John21"

A good mental rule is:

If you want to store or combine something inside a string, convert it to text first.

The most direct solution in modern C++ is std::to_string.

#include <string>
#include <iostream>

int main() {
    std::string name = "John";
    int age = 21;

    std::string result = name + std::to_string(age);

    std::cout << result << '\n';
}

Output:

John21

Why this works

• name is already a std::string
• std::to_string(age) converts 21 into the string "21"
• now both parts are strings, so + can concatenate them

Another example

#include <string>


{
    std::string product = ;
     id = ;

    std::string code = product + std::(id);
    std::cout << code << ;
}

Consider this example:

#include <string>
#include <iostream>

int main() {
    std::string name = "John";
    int age = 21;
    std::string result = name + std::to_string(age);

    std::cout << result << '\n';
}

Step by step:

1. std::string name = "John";

   • Creates a string variable containing the text "John".

2. int age = 21;

   • Creates an integer variable containing the number 21.

3. std::to_string(age)

   • Converts the integer 21 into the string "21".

4. name + std::to_string(age)

Combining strings with numbers appears everywhere in C++ programs.

1. Building usernames or labels

std::string username = "user" + std::to_string(1001);

Result: "user1001"

2. Creating file names

std::string filename = "report_" + std::to_string(2024) + ".txt";

Result: "report_2024.txt"

3. Logging

std::string message = "Request failed with code " + std::to_string(404);

4. API or route construction

std::string path = "/users/" + std::to_string(42);

5. Game development

std::string levelName = "Level " + std::to_string(3);

These patterns are common whenever numbers must appear as readable text.

In real projects, developers often use a few common patterns when mixing strings and numbers.

Using std::to_string for simple cases

For short, readable concatenation:

std::string key = "item_" + std::to_string(id);

This is the most common choice for straightforward cases.

Using streams when building larger messages

std::ostringstream oss;
oss << "User " << userId << " has score " << score;
std::string message = oss.str();

This is useful when:

• combining many values
• formatting more complex text
• appending different data types in sequence

Validation before building strings

Developers often validate values before converting them:

if (age < 0) {
    return "Invalid age";
}

return name + std::to_string(age);

This is an example of a guard clause: check bad input early, then continue with the normal logic.

Configuration and identifiers

Strings with numbers are commonly used for:

Here are common beginner mistakes when concatenating strings and integers in C++.

Mistake 1: Adding a string and an int directly

std::string result = name + age; // error

Why it fails:

• name is text
• age is a number
• C++ does not automatically convert the int to std::string here

Fix:

std::string result = name + std::to_string(age);

Mistake 2: Forgetting the correct header

std::string needs:

#include <string>

If you use streams, you also need:

#include <sstream>

Mistake 3: Confusing output streaming with string concatenation

This works for printing:

Here is how common approaches compare.

// Simple solution
std::string result = name + std::to_string(age);

Rules

• std::string stores text
• int stores numbers
• Convert numbers to strings before concatenation
• Include #include <string> for std::string
• Include #include <sstream> if using string streams

Common patterns

std::string a = "User" + std::to_string(7);
std::string b = std::string("User") + std::to_string(7);

Stream version

std::ostringstream oss;
oss << name << age;
std::string result = oss.str();

Printing is different from building a string

std::cout << name << age; // prints

std::string result = name + std::(age); 

Can I directly add an int to a std::string in C++?

No. You must first convert the integer into a string, usually with std::to_string.

What is the easiest way to concatenate a std::string and an integer?

Use:

std::string result = name + std::to_string(age);

Why does std::cout << name << age work if name + age does not?

std::cout uses stream insertion operators to print different types. String concatenation with + requires compatible string operands.

Should I use std::to_string or ostringstream?

Use std::to_string for simple cases. Use ostringstream when building more complex formatted strings.

Does "John" + 21 create "John21"?

No. With a string literal, with an integer performs pointer arithmetic, not string concatenation.

• std::string — the main C++ type for working with text.
• Type conversion — needed when changing a value from one type to another.
• std::to_string — converts numeric values into strings.
• std::ostringstream — builds strings using stream syntax.
• Operator overloading — explains why + behaves differently for strings and numbers.
• C++ stream output — related because std::cout << value can combine different types when printing.
• String literals — important because "text" + number can behave unexpectedly.
• C++11 features — relevant because std::to_string was introduced in C++11.