A Deeper Look at the std::string Class

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, 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>

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}

1Hello World

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}

1Hello World

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;

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}

1Hello World
2That was a std::string

String Copying

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}

1Hello World

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}

1Hello World

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}

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

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

Move Semantics

Learn how we can improve the performance of our types using move constructors, move assignment operators and std::move()

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}

10000004E9FBFF5A8: Hello

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

String Length

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}

1Length: 5

std::string objects also have the size() method, which does the same thing. This is included for parity with other standard library containers such as std::vector and std::array, thereby making it easier to write templates.

Comparing Strings

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}

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

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}

1Animal1 and Animal2 are equal
2Bear comes before Zebra

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}

1Animal1 and Animal2 are equal
2Bear comes before Zebra

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.

Below, we sort a range of std::string objects into alphabetical order:

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}

1Alligator
2Bear
3Chicken
4Zebra

Finding Substrings

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}

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

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 fight";
10  }
11}

1There is no dog in this fight

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}

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

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.

Creating Substrings

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}

1First 5 characters: Hello

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}

1Last word: World

Accessing Individual Characters

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}

1The first character is H
2The last character d

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 allowed, but dangerous";
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}

1That was allowed, but dangerous
2That was an exception:
3invalid string position

Concatenating

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

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}

1Hello World

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}

1Hello World!

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

Converting a 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
26.28
36.28

Converting a Number to a 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}

142

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.

Summary

In this lesson, we've explored the std::string class, demonstrating how it simplifies string manipulation compared to C-style strings.

Key Learnings

• How to include and use the std::string class.
• Creating std::string objects from C-style strings and using std::string literals.
• Copying and moving std::string objects.
• Comparing std::string objects using operators and the compare() method.
• Finding substrings and characters within a std::string using find(), rfind(), and C++20/23 methods like starts_with(), ends_with(), and contains().
• Accessing and modifying characters in a std::string using the at() method and [] operator.
• Generating substrings with the substr() method.
• Concatenating std::string objects and converting between std::string and numeric types.

Next Lesson

Manipulation and Memory Management of std::string

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

ContinueView Course