C++ string concatenation: +, += and append()

C++ string concatenation is done with the + operator: first + " " + last builds a new std::string from the pieces and leaves them unchanged. To add to the end of a string you already have, use += or append(). At least one side of every + must be a std::string, and a number has to go through std::to_string first.

#include <iostream>
#include <string>

int main() {
    std::string first = "Ada";
    std::string last = "Lovelace";

    std::string full = first + " " + last;
    std::cout << full << '\n';  // Ada Lovelace
}

It printed:

Ada Lovelace

This answer is written for C++17; the one line that needs C++20 says so. The samples were built with MSVC 19.44, Clang 19.1 (MSVC STL), GCC 16.2 and Clang 23.1 (libc++). All four printed the same for every sample, and the comment on each output line is what it printed.

How do you append to a string in C++?

Use + when you want a new string, and += or append() when you want to make an existing string longer. + leaves both pieces as they were; += adds to the end of the string on its left. append() does what += does for a string or a literal, and can also add part of a string or one character repeated (std::basic_string::append). It has no one-character form, so name.append('!') does not compile: a single character goes on with += '!', push_back('!') or append(1, '!').

With first and last from above:

std::string name = first;
name += " ";                 // a literal
name += last;                // a std::string
std::cout << name << '\n';   // Ada Lovelace
name += '!';                 // one char
std::cout << name << '\n';   // Ada Lovelace!
name.push_back('!');         // one char, the same way
std::cout << name << '\n';   // Ada Lovelace!!

std::string greeting = "Hello, ";
greeting.append(first);          // the whole string
std::cout << greeting << '\n';   // Hello, Ada
greeting.append(3, '!');         // one char, three times
std::cout << greeting << '\n';   // Hello, Ada!!!

std::string handle = "@";
handle.append(first);
handle.append(last, 0, 3);       // 3 chars of last, from 0
std::cout << handle << '\n';     // @AdaLov

Why does "Hello, " + "world" not compile?

Because neither side is a std::string. A quoted literal such as "Hello, " is an array of const char: eight of them, seven characters and the '\0' that ends it. For +, C++ turns each array into a pointer to its first character, and two pointers cannot be added.

std::string greeting = "Hello, " + "world";  // does not compile

GCC’s first error line:

error: invalid operands of types 'const char [8]' and 'const char [6]' to binary 'operator+'

MSVC and both Clang builds reject it too. The rule holds for each +, read from the left: "Hello, " + "dear " + first fails at its first + with the same error, while "Hello, " + first + "!" compiles. The fix is to make one side a std::string, by constructing one or with the s suffix, or to drop the +:

// 1. Make the left side a std::string.
std::string a = std::string("Hello, ") + "world";

// 2. The s suffix makes the literal a std::string.
using namespace std::string_literals;
std::string b = "Hello, "s + "world";

// 3. Side by side, no +: the compiler joins them.
std::string c = "Hello, " "world";

All three printed Hello, world. The suffix needs the using directive, which brings std::string_literals into scope. The side-by-side form works for literals only.

How do you add a number to a string in C++?

Convert the number with std::to_string first, then join as usual; converting an int to a string covers the other ways.

int age = 36;

std::string label = "Age: " + std::to_string(age);
std::cout << label << '\n';  // Age: 36

Without the conversion, std::string label = text + 5;, where text is a std::string, does not compile on any of the four: GCC reports no match for 'operator+', MSVC error C2676. Two close relatives do compile, and print something you did not ask for:

std::string text = "Age: ";
text += 65;                  // the char with code 65, 'A'
std::cout << text << '\n';   // Age: A

std::string tail = "abc" + 1;  // skips the first char
std::cout << tail << '\n';     // bc

text += 65 compiles where text + 5 did not because += is a member function that takes a single char, so the int quietly converts to one (std::basic_string::operator+=). The + for strings is a template, written once for every character type, that has to work out one character type from both sides; it cannot make an int fit, so no version of it applies.

"abc" + 1 never meets a std::string: the literal becomes a pointer to its first character, and + 1 moves it one character on (the standard’s rule for +).

You cannot count on a warning: at -Wall -Wextra (/W4 on MSVC), none of the four warned about text += 65, and with an int variable in place of the 65 only MSVC did (C4244). Add -Wconversion and GCC and Clang warn about the variable too. Only the two Clang builds flagged "abc" + 1: adding 'int' to a string does not append to the string.

How do you join many strings in a loop?

Start with an empty string and += each piece, adding the separator before every piece but the first:

std::vector<std::string> names = {"Ada", "Grace", "Alan"};

std::string joined;
for (std::size_t i = 0; i < names.size(); ++i) {
    if (i > 0) {
        joined += ", ";  // before every name but the first
    }
    joined += names[i];
}
std::cout << joined << '\n';  // Ada, Grace, Alan

std::string first = "Ada";
int age = 36;
double score = 92.5;

std::ostringstream out;
out << first << ", age " << age << ", score " << score;
std::string line = out.str();
std::cout << line << '\n';  // Ada, age 36, score 92.5

The second half is for pieces that mix text and numbers: a std::ostringstream, from <sstream>, takes them all with << the way std::cout does, and str() returns a copy of the result as a std::string.

What about strcat and C strings?

std::strcat, from <cstring>, is C’s way: it copies one C string onto the end of another inside a char array you sized yourself, and it does not check that the result fits. If the array is too small, the behavior is undefined, which means the program may do anything (std::strcat).

A correct call, std::strcat(buffer, ", world") into char buffer[32] = "Hello", printed Hello, world on all four. On Windows, MSVC (warning C4996) and Clang both called it unsafe and suggested strcat_s, a warning that comes from the Windows C runtime’s header; GCC and Clang on Linux said nothing.

In C++, use std::string, which grows as needed. A C string can still take part in + as long as the other side is a std::string, as the literal "Age: " did above.

Is std::format better? (C++20)

For text with values in the middle, yes: since C++20, std::format from <format> fills each {} with the next argument, numbers included, and returns a std::string (std::format).

std::string line = std::format("{} is {}", first, age);  // C++20
std::cout << line << '\n';  // Ada is 36

first and age are from above. Build it as C++20 (-std=c++20, or /std:c++20 on MSVC); all four did, and Since When’s C++20 table gives the first GCC, Clang and MSVC release with std::format. Before C++20, the std::ostringstream above does the same job.

Which one should you use?

The rest of std::string, from its length to find(), is in how a C++ string works. Standard library has the other answers on strings and containers.