A Deeper Look at the `std::string` Class

A detailed guide to std::string, covering the most essential methods and operators

This lesson is part of the course:

Professional C++

Comprehensive course covering advanced concepts, and how to use them on large-scale projects.

Ryan McCombe

Posted 4 months ago

In this lesson, we’ll dive deeper into the std::string objects we’ve been so heavily relying on.

We’ll investigate how they’re created, how they’re moved and copied, and some of the most valuable methods we have to interact with them.

std::string solves many of the problems of C-style strings and is much easier to work with. So, where possible, we should prefer to use std::string objects over C-style strings where possible.

The next few lessons will outline many of the reasons why.

Creating a `std::string`

The std::string class and its associated utilities are available by including <string>:

1#include <string>
2

As we’ve seen, std::string objects can be created from C-style strings. Typically, this is done from C-style string literals, but it doesn’t need to be:

1#include <iostream>
2#include <string>
3
4int main(){
5  std::string StringA{"Hello"};
6
7  const char* CString{" World"};
8  std::string StringB{CString};
9
10  std::cout << StringA << StringB;
11}
12

1Hello World
2

We can go in the opposite direction, generating a C-style string from a std::string using the c_str() method:

1#include <iostream>
2#include <string>
3
4int main(){
5  std::string StringA{"Hello World"};
6  const char* CString{StringA.c_str()};
7
8  std::cout << CString;
9}
10

1Hello World
2

`std::string` Literals

The standard library includes a way to create std::string literals.

To use them, we need to include a using statement:

1using namespace std::string_literals;
2

In larger projects, statements like this would typically be part of a file that gets included in every other file.

Once we’ve implemented the using statement, we can use std::string literals in a similar way we use C-style strings.

We wrap them in double quotes, however, for std::string we append an s to the end:

1#include <iostream>
2#include <string>
3
4using namespace std::string_literals;
5
6int main(){
7  auto MyString{"Hello World"s};
8  std::cout << MyString;
9
10  if constexpr (std::same_as<
11    decltype(MyString), std::string>) {
12    std::cout << "\nThat was a std::string";
13  }
14}
15

1Hello World
2That was a std::string
3

Copying a `std::string`

One of the main benefits of std::string over C-style strings is that copying and moving them works in much the same way as any other modern data type.

We can deep copy a std::string simply using the = operator:

1#include <iostream>
2#include <string>
3
4int main(){
5  std::string StringA{" World"};
6  std::string StringB = StringA;
7  StringA = "Hello";
8
9  std::cout << StringA << StringB;
10}
11

1Hello World
2

Passing by value also creates a deep copy:

1#include <iostream>
2#include <string>
3
4void Update(std::string Copy){
5  Copy = "Hello";
6  std::cout << Copy;
7}
8
9int main(){
10  std::string StringA{" World"};
11  Update(StringA);
12  std::cout << StringA;
13}
14

1Hello World
2

References (both l-value and r-value) work as they do with any other type:

1#include <iostream>
2#include <string>
3
4using namespace std::string_literals;
5
6void Log(std::string& LValue){
7  std::cout << "L-Value: " << LValue << '\n';
8}
9
10void Log(std::string&& RValue){
11  std::cout << "R-Value: " << RValue << '\n';
12}
13
14int main(){
15  std::string MyString{"Hello"};
16  Log(MyString);
17  Log("World"s);
18
19  std::string AnotherString{"Bye!"};
20  Log(std::move(AnotherString));
21}
22

1L-Value: Hello
2R-Value: World
3R-Value: Bye!
4

We cover l-values and r-values in our lesson on move semantics

Move Semantics, `std::move` and rvalues

Learn how to implement move semantics in C++, the difference between lvalues and rvalues, and what std::move really does.

If we want to get a pointer to a std::string, we can do so in the usual way, using the address-of operator &:

1#include <iostream>
2#include <string>
3
4int main(){
5  std::string MyString{"Hello"};
6  std::string* Pointer{&MyString};
7
8  std::cout << Pointer << ": " << *Pointer;
9}
10

10000004E9FBFF5A8: Hello
2

Another common way to pass std::string objects in modern C++ is through a string view, which we’ll cover later in this chapter.

Getting the Length of a `std::string`

We can get the length of a std::string using the length() method:

1#include <iostream>
2#include <string>
3
4int main(){
5  std::string MyString{"Hello"};
6  std::cout << "Length: " << MyString.length();
7}
8

1Length: 5
2

std::string objects also have the size() method, which does the same thing and is included for parity with other std::library containers such as std::vector and std::array

Comparing `std::string` objects

We can check if two std::string contain the same content using the == and != operators:

1#include <iostream>
2#include <string>
3
4int main(){
5  std::string Animal1{"Bear"};
6  std::string Animal2{"Bear"};
7  std::string Animal3{"Zebra"};
8
9  if (Animal1 == Animal2) {
10    std::cout <<
11      "Animal1 and Animal2 are equal";
12  }
13
14  if (Animal2 != Animal3) {
15    std::cout <<
16      "\nAnimal2 and Animal3 are not equal";
17  }
18}
19

1Animal1 and Animal2 are equal
2Animal2 and Animal3 are not equal
3

std::string objects also have the compare() method. This returns an integer, which has the same meaning as the integer C-style string’s strcmp() function:

If the integer is negative, the first string comes before the second string in the dictionary order
If the integer is zero, the two strings are the same
If the integer is positive, the first string comes after the second string in the dictionary order

Here is an example:

1#include <iostream>
2#include <string>
3
4int main(){
5  std::string Animal1{"Bear"};
6  std::string Animal2{"Bear"};
7  std::string Animal3{"Zebra"};
8
9  if (Animal1.compare(Animal2) == 0) {
10    std::cout <<
11      "Animal1 and Animal2 are equal\n";
12  }
13
14  if (Animal2.compare(Animal3) < 0) {
15    std::cout <<
16      Animal2 << " comes before " << Animal3;
17  }
18}
19

1Animal1 and Animal2 are equal
2Bear comes before Zebra
3

std::string objects also implement the usual comparison operators - <, <=, !=, and so on:

1#include <iostream>
2#include <string>
3
4int main(){
5  std::string Animal1{"Bear"};
6  std::string Animal2{"Bear"};
7  std::string Animal3{"Zebra"};
8
9  if (Animal1 == Animal2) {
10    std::cout <<
11      "Animal1 and Animal2 are equal\n";
12  }
13
14  if (Animal2 < Animal3) {
15    std::cout <<
16      Animal2 << " comes before " << Animal3;
17  }
18}
19

1Animal1 and Animal2 are equal
2Bear comes before Zebra
3

Because the std::string class implements all the comparison operators (or, since C++20, the spaceship operator), it can automatically compare the order of its objects:

1#include <algorithm>
2#include <string>
3#include <iostream>
4#include <vector>
5
6using namespace std::string_literals;
7
8int main(){
9  std::vector Animals{
10    "Bear"s, "Zebra"s, "Chicken"s,
11    "Alligator"s};
12
13  std::ranges::sort(Animals);
14
15  for (const std::string& Animal : Animals) {
16    std::cout << Animal << '\n';
17  }
18}
19

1Alligator
2Bear
3Chicken
4Zebra
5

Finding Substrings in a `std::string`

We can search our strings for specific substrings or individual characters using the find() and rfind() methods.

find() will return an integer representing the position where the first instance of the substring starts. rfind() will return the position of the last instance.

If there there aren’t multiple instances of the substring, find() and rfind() will return the same thing.

1#include <string>
2#include <iostream>
3
4int main(){
5  std::string MyString(
6    "The cat slapped the other cat");
7
8  std::cout << "First cat starts at: " <<
9    MyString.find("cat");
10  std::cout << "\nSecond cat starts at: " <<
11    MyString.rfind("cat");
12}
13

1First cat starts at: 4
2Second cat starts at: 26
3

If the substring is not found, these methods return a value that will pass an equality check with std::string::npos:

1#include <string>
2#include <iostream>
3
4int main(){
5  std::string String(
6    "The cat slapped the other cat");
7
8  if (String.find("dog") == std::string::npos) {
9    std::cout << "There is no dog in this tale";
10  }
11}
12

1There is no dog in this tale
2

The simpler starts_with(), ends_with(), and contains() methods return true if a string starts with, ends with, or contains a substring respectively.

Note: starts_with() and ends_with() were added in the C++20 specification, and contains() in C++23. As a result, they may not yet be supported by your compiler.

1#include <string>
2#include <iostream>
3
4int main(){
5  std::string String(
6    "The cat slapped the other cat");
7
8  if (String.starts_with("The")) {
9    std::cout << "It starts with \"The\"";
10  }
11
12  if (String.ends_with("cat")) {
13    std::cout << "\nIt ends with \"cat\"";
14  }
15
16  if (String.contains("slapped")) {
17    std::cout << "\nSomething got slapped";
18  }
19}
20

1It starts with "The"
2It ends with "cat"
3Something got slapped
4

For more complex use cases, a technique called regular expressions (regex) gives us significantly more flexibility in searching our strings.

We cover regular expressions later in this chapter.

Getting Characters in a `std::string`

We can access any character in std::string using the at() or [] operators, passing in the index of the character we’re interested in:

1#include <string>
2#include <iostream>
3
4int main(){
5  std::string String("Hello World");
6
7  std::cout << "The first character is "
8   << String[0];
9  std::cout << "\nThe last character "
10    << String.at(String.size() - 1);
11}
12

1The first character is H
2The last character d
3

The at() method will perform bounds-checking on the index we pass, to ensure it is valid.

The [] operator will skip this check when compiling in a non-debug configuration. This has a minor performance gain at the cost of undefined behavior if the index is out of bounds.

1#include <string>
2#include <iostream>
3
4int main(){
5  std::string String("Hello World");
6
7  String[100] = 42;
8  std::cout << "That was fine";
9
10  try { String.at(100) = 42; }
11  catch (std::out_of_range& Error) {
12    std::cout << "\nThat was an exception:\n"
13      << Error.what();
14  }
15}
16

1That was fine
2That was an exception:
3invalid string position
4

Getting Substrings in a `std::string`

We can generate a substring using the substr() method, passing in the position we want the substring to start, and how many characters we want it to have:

1#include <string>
2#include <iostream>
3
4int main(){
5  std::string String("Hello World");
6  std::cout << "First 5 characters: "
7    << String.substr(0, 5);
8}
9

1First 5 characters: Hello
2

The second argument is optional, which means our substring will continue until the end of the original string:

1#include <string>
2#include <iostream>
3
4int main(){
5  std::string String("Hello World");
6  size_t LastSpace{String.rfind(' ')};
7  std::cout << "Last word: "
8    << String.substr(LastSpace + 1);
9}
10

1Last word: World
2

Concatenating a `std::string`

We can generate new std::string objects by concatenating other strings together, using the + operator. The `std::string:

1#include <string>
2#include <iostream>
3
4int main(){
5  std::string StringA("Hello");
6  std::string StringB(" World");
7  std::string Combined{StringA + StringB};
8
9  std::cout << Combined;
10}
11

1Hello World
2

This also works with objects that can be converted to std::strings, such as C-style strings and characters:

1#include <string>
2#include <iostream>
3
4int main(){
5  std::string StringA("Hello");
6  std::string StringB("World");
7  std::string Combined{
8    StringA + " " + StringB + '!'};
9
10  std::cout << Combined;
11}
12

1Hello World!
2

Our next lesson covers a range of ways we can modify existing std::string objects in place.

Converting a `std::string` to a Number

Often, we’ll have a std::string object that contains a number, and we’ll want to convert it to a built-in numeric type. The most common needs can be met by:

std::stoi - convert a std::string to an int
std::stof - convert a std::string to a float
std::stod - convert a std::string to a double

1#include <string>
2#include <iostream>
3
4int main(){
5  std::string Pi{"3.14"};
6
7  int PiInt{std::stoi(Pi)};
8  float PiFloat{std::stof(Pi)};
9  double PiDouble{std::stod(Pi)};
10
11  std::cout
12    << PiInt * 2 << '\n'
13    << PiFloat * 2 << '\n'
14    << PiDouble * 2;
15}
16

Conversion a Number to a `std::string`

We can go the other way, converting a numeric type to a std::string using the std::to_string() function:

1#include <string>
2#include <iostream>
3
4int main(){
5  float Number{42};
6
7  std::string String{std::to_string(Number)};
8  std::cout << String;
9}
10

142
2

In the next lesson, we’ll look at more properties and methods of std::string, and how they can interact with the standard library algorithms.

Was this lesson useful?

Ryan McCombe

Posted 4 months ago

This lesson is part of the course:

Professional C++

Comprehensive course covering advanced concepts, and how to use them on large-scale projects.

Whirlwind Tour of C++ Basics

Memory Management

Templates

Arrays and Linked Lists

Standard Library Data Structures

Working with Functions

Iterators and Algorithms

Standard Library Algorithms

Exceptions and Error Handling

Objects, Classes and Modules

Strings and Streams

92. A Deeper Look at the `std::string` Class

A detailed guide to std::string, covering the most essential methods and operators

Files and Serialization

This lesson is part of the course:

Professional C++

Comprehensive course covering advanced concepts, and how to use them on large-scale projects.

Free, unlimited access!

This course includes:

106 Lessons
550+ Code Samples
96% Positive Reviews
Regularly Updated
Help and FAQ

Next Lesson

`std::string` Manipulation and Memory Management

A practical guide covering the most useful methods and operators for working with std::string objects and their memory

Contact|Privacy Policy|Terms of Use

A Deeper Look at the std::string Class

Professional C++

Ryan McCombe

Creating a std::string

std::string Literals

Copying a std::string

Move Semantics, std::move and rvalues

Getting the Length of a std::string

Comparing std::string objects

Finding Substrings in a std::string

Getting Characters in a std::string

Getting Substrings in a std::string

Concatenating a std::string

Converting a std::string to a Number

Conversion a Number to a std::string

Was this lesson useful?

Ryan McCombe

Professional C++

Whirlwind Tour of C++ Basics

Memory Management

Templates

Arrays and Linked Lists

Standard Library Data Structures

Working with Functions

Iterators and Algorithms

Standard Library Algorithms

Exceptions and Error Handling

Objects, Classes and Modules

Strings and Streams

92.

A Deeper Look at the std::string Class

Files and Serialization

Professional C++

This course includes:

std::string Manipulation and Memory Management

A Deeper Look at the `std::string` Class

Creating a `std::string`

`std::string` Literals

Copying a `std::string`

Move Semantics, `std::move` and rvalues

Getting the Length of a `std::string`

Comparing `std::string` objects

Finding Substrings in a `std::string`

Getting Characters in a `std::string`

Getting Substrings in a `std::string`

Concatenating a `std::string`

Converting a `std::string` to a Number

Conversion a Number to a `std::string`

A Deeper Look at the `std::string` Class

`std::string` Manipulation and Memory Management