C++ string (std::string) explained with examples

A C++ string is a std::string, the standard library’s type for text, declared in the header <string>. It owns its characters, grows as needed and frees its memory by itself. Create one with std::string name = "Ada";, join strings with +, get the length with size(), and search with find(), which returns std::string::npos when nothing is found.

#include <iostream>
#include <string>

int main() {
    std::string name = "Ada";
    std::string greeting = "Hello, " + name + "!";
    std::cout << greeting << '\n';                    // Hello, Ada!
    std::cout << "size: " << greeting.size() << '\n'; // size: 11
}

It printed:

Hello, Ada!
size: 11

This answer is written for C++17, which added std::string_view (Since When’s C++17 table). The samples were built with MSVC 19.44, Clang 19.1 (MSVC STL), GCC 16.2 and Clang 23.1 (libc++), and all four printed the same unless a sentence says otherwise.

How do you create a string in C++?

You create a std::string from a literal, empty, from one character repeated, or as a copy of another string:

std::string email = "ada@example.com";  // from a literal
std::string blank;                      // empty: size 0
std::string line(10, '-');              // 10 copies of '-'
std::string copy = email;               // its own characters

copy[0] = 'A';                          // email is unchanged

A copy owns its characters, so after the change email still printed ada@example.com and copy printed Ada@example.com. An empty std::string is a valid string of length 0, not a null pointer: even its c_str(), which gives the text as a C string, was not null. Each sample below starts from this email.

How do you get the length of a string in C++?

Call size() or length(): they return the same number, 15 for "ada@example.com", and empty() tells you whether that number is 0. The number counts bytes (chars), not letters. The word “café”, written as its UTF-8 bytes "caf\xC3\xA9", has a size() of 5 for four letters: UTF-8 stores the é in two bytes.

How do you concatenate strings in C++?

For string concatenation, use + to make a new string, and += or append() to add to an existing one; push_back() adds a single character:

std::string user = "ada";
std::string domain = "example.com";

std::string email = user + "@" + domain;   // a new string
std::cout << email << '\n';                // ada@example.com

std::string greeting = "Hello";
greeting += ", ";              // adds to greeting itself
greeting.append(user);         // the same, as a function
greeting.push_back('!');       // one character
std::cout << greeting << '\n'; // Hello, ada!

append() has no overload that takes one char, so add one with push_back() or append(1, '!').

One side of + must be a std::string. A literal such as "Hello, " is an array of const char, not a std::string, and + has no overload for two of them:

std::string s = "Hello, " + "world";   // error: two literals

GCC’s error names both array types: invalid operands of types 'const char [8]' and 'const char [6]' to binary 'operator+'. MSVC says '+': cannot add two pointers. Make one side a string, std::string("Hello, ") + "world", and it works. That is also why the first example compiled: "Hello, " + name has a std::string on one side, its result is a std::string, and so the + "!" after it has one too.

How do you read or change one character in a string?

Write s[i] to read or change the character at position i, counting from 0, or s.at(i) to have the position checked. Past the end, [] is undefined behavior, meaning the program may do anything, while at() throws std::out_of_range:

std::cout << email[0] << '\n';       // a: positions start at 0
std::cout << email.back() << '\n';   // m: the last character
email[0] = 'A';                      // change one character
std::cout << email << '\n';          // Ada@example.com

int dots = 0;
for (char c : email) {               // every character in turn
    if (c == '.') ++dots;
}
std::cout << "dots: " << dots << '\n';   // dots: 1

try {
    std::cout << email.at(99) << '\n';   // checked: throws
} catch (const std::out_of_range& e) {
    std::cout << "out_of_range: " << e.what() << '\n';
}

The range-for loop, for (char c : email), hands you each character in turn, here to count the dots. All four caught the std::out_of_range from at(99); each standard library words the message from what() its own way.

How do you find text in a C++ string? (find and npos)

find() returns the position of the first match, or std::string::npos when there is none, so compare the result with npos:

std::cout << email.find('@') << '\n';         // 3
std::cout << email.find("example") << '\n';   // 4

std::size_t pos = email.find("xyz");
if (pos == std::string::npos) {               // the right test
    std::cout << "xyz: not found\n";
}
std::cout << std::string::npos << '\n';       // the largest size_t

if (email.find("ada")) {             // wrong: the match is at 0
    std::cout << "ada: found\n";
} else {
    std::cout << "ada: not found\n"; // printed, though it is there
}
if (email.find("xyz")) {             // npos is not 0, so true
    std::cout << "xyz: found\n";     // printed, though it is not
}

npos is the largest value of the unsigned type that positions use: on a 64-bit build, all four printed 18446744073709551615. A test such as if (email.find("ada")) asks whether the position is nonzero, not whether there was a match. A match at position 0 converts to false, and npos, being nonzero, converts to true, so the program printed ada: not found and xyz: found. No compiler warned about either test, at /W4 or at -Wall -Wextra.

How do you get a substring in C++? (substr)

substr(pos, count) returns a new string holding count characters from position pos; leave count out to take everything to the end. With find(), it splits the address in two:

std::size_t at = email.find('@');            // 3
std::string user = email.substr(0, at);      // 3 characters from 0
std::string domain = email.substr(at + 1);   // from 4 to the end
std::cout << user << '\n';                   // ada
std::cout << domain << '\n';                 // example.com

std::cout << email.substr(4, 100) << '\n';   // cut short at the end
try {
    std::cout << email.substr(99) << '\n';   // past the end: throws
} catch (const std::out_of_range& e) {
    std::cout << "out_of_range: " << e.what() << '\n';
}

A count that runs past the end is cut short, so substr(4, 100) printed example.com. A pos past the end throws std::out_of_range. The substring is a copy: changing user leaves email as it was.

How should a function take a string?

Take a string the function only reads as const std::string& or, since C++17, as std::string_view, a view of characters someone else owns. Passed a std::string, neither copies the text. Passed a literal, they differ: a const std::string& parameter needs a temporary std::string built from it, a copy of the text, while a std::string_view points at the literal’s own characters.

std::string_view domain_of(std::string_view email) {
    return email.substr(email.find('@') + 1);
}

When to pass by value or by const reference covers every other parameter type.

The std::string functions you will use most

Each example works on email unless it names another string.

Numbers to and from strings have their own answers: C++ string to int with std::stoi, and C++ int to string with std::to_string. To read a line of input into a string, use std::getline; to compare two, see C++ string comparison. Standard library has the answers on the library’s other types.