Manipulating std::string Objects

In this lesson, we’ll finish our exploration of the std::string type by investigating:

• The most useful std::string methods and operators for manipulating the string’s contents
• How to use generic standard library algorithms with std::string objects, drastically increasing our options
• The std::basic_string class, which allows us to customize the character type our strings use
• How memory is managed within standard library strings, and how we can intervene in that process to get some performance improvements

Appending Content

We can append content to the end of an existing string, using the append() method, or the += operator:

1#include <iostream>
2#include <string>
3
4int main(){
5  std::string Greeting{"Hello"};
6  Greeting.append(" World");
7  Greeting += '!';
8
9  std::cout << Greeting;
10}

1Hello World!

The append() method also has some alternative signatures, giving us more options.

For example, we can append a sequence of characters:

1#include <iostream>
2#include <string>
3
4int main(){
5  std::string Greeting{"Hello"};
6  Greeting.append(10, '!');
7  std::cout << Greeting;
8}

1Hello!!!!!!!!!!

Or we can append a substring by passing the starting position in the string to append, and the number of characters to append:

1#include <iostream>
2#include <string>
3
4int main(){
5  std::string Greeting{"Hello "};
6  std::string Options{"World,Everyone,Friends"};
7
8  // Starting from position 15, append 7 characters
9  Greeting.append(Options, 15, 7);
10
11  std::cout << Greeting;
12}

1Hello Friends

append_range()

We can also append a range to a string using the append_range() method. This will typically be the case when what we want to append is in a different type of container, or the result of an algorithm:

1#include <iostream>
2#include <string>
3#include <array>
4
5int main(){
6  std::string Greeting{"Hello "};
7  std::array Characters{
8    'W', 'o', 'r', 'l', 'd'};
9
10  Greeting.append_range(Characters);
11
12  std::cout << Greeting;
13}

1Hello World

Note: append_range() was added to the specification in C++23, so may not yet be available on all compilers.

Inserting Content

If we need to insert content into the middle of a string, we have two main options: insert() and insert_range()

The most common use of insert() involves passing the insertion position, and the string to insert:

1#include <iostream>
2#include <string>
3
4int main(){
5  std::string Greeting{"Hello!"};
6  Greeting.insert(5, " World");
7  std::cout << Greeting;
8}

1Hello World!

insert_range()

Since C++23, we also have the insert_range() method, which allows us to insert content from any range-based container. Unlike the basic insert(), the insert_range() requires an iterator to specify the insertion position.

std::string objects come with the usual suite of iterators which we can generate from methods like begin():

1#include <iostream>
2#include <string>
3#include <array>
4
5int main(){
6  std::string Greeting{"Hello!"};
7  std::array Characters{
8    ' ', 'W', 'o', 'r', 'l', 'd'};
9
10  Greeting.insert_range(Greeting.begin() + 5,
11                        Characters);
12
13  std::cout << Greeting;
14}

1Hello World!

Note: insert_range() was added to the specification in C++23, so may not yet be available on all compilers.

We cover iterators in more detail in our earlier chapter, covering containers:

Iterators and Ranges

This lesson offers an in-depth look at iterators and ranges, emphasizing their roles in container traversal

Erasing Contents

The erase() method gives us the ability to remove all or some of the characters in our string.

In its most basic usage, the erase() method accepts a starting position, and the quantity of characters to erase.

1#include <iostream>
2#include <string>
3
4int main(){
5  std::string Greeting{"Hello World!"};
6
7  // Starting from index 5, erase 6 characters
8  Greeting.erase(5, 6);
9
10  std::cout << Greeting;
11}

1Hello!

Both arguments to erase() are optional. By default, the first argument is 0, ie the beginning of the string, and the second argument is the end of the string:

1// Erase all characters
2MyString.erase();
3
4// Erase everything except the first 5 characters
5MyString.erase(5);
6
7// Erase the first 6 characters
8MyString.erase({}, 6);

Replacing Contents

Finally, we can replace parts of our string, effectively combining both an erase() and an insert().

The most common usage of the replace() function involves replacing part of the calling string with new content. This involves passing three arguments:

• The position of the first character in the string to replace
• The number of characters to replace
• The string to replace it with

The number of characters to replace does not need to be the same as the number of characters we’re replacing it with. The string will resize as needed:

1#include <iostream>
2#include <string>
3
4int main(){
5  std::string Greeting{"Hello World!"};
6
7  // Starting from index 6, replace 5 characters
8  Greeting.replace(6, 5, "Everyone");
9
10  std::cout << Greeting;
11}

1Hello Everyone!

replace_with_range()

Since C++23, we also have the replace_with_range() function. It behaves similarly but allows the replacement content to be sourced from a range. Instead of a starting index and a count, we provide an iterator pair representing the range of characters we want to replace in the original string:

1#include <iostream>
2#include <string>
3#include <array>
4
5int main(){
6  std::string Greeting{"Hello World!"};
7  std::array Characters{
8    'E', 'v', 'e', 'r', 'y', 'o', 'n', 'e'};
9
10  Greeting.replace_with_range(
11    Greeting.begin() + 6, Greeting.begin() + 11,
12    Characters);
13
14  std::cout << Greeting;
15}

1Hello Everyone!

Note: replace_with_range() was added to the specification in C++23, so may not yet be available on all compilers.

Iterators and Algorithms

Like many standard library collections, std::string includes the usual suite of iterators. This allows traversal through its characters in a standardized way.

The most basic implication of this is that we use a range-based for loop to iterate over the characters of a std::string:

1#include <iostream>
2#include <string>
3
4int main(){
5  std::string Greeting{"Hey"};
6
7  for (const char& Character : Greeting) {
8    std::cout << Character << '\n';
9  }
10}

1H
2e
3y

These iterators also allow std::strings to be compatible with iterator-based algorithms.

In this example, we use the std::reverse() algorithm to reverse the characters in a std::string:

1#include <iostream>
2#include <string>
3#include <algorithm>
4
5int main(){
6  std::string String{"12345"};
7  std::reverse(String.begin(), String.end());
8  std::cout << String;
9}

154321

Since std::string objects are also ranges, we can use all the range-based features we covered in the earlier algorithms chapter, such as views, projection, and range-based algorithms.

Here, we approximate the number of words in a string by using the std::ranges::count() algorithm to return the number of spaces it has:

1#include <algorithm>
2#include <iostream>
3#include <string>
4
5int main(){
6  std::string String{"The quick brown fox"};
7
8  std::cout << "The string has "
9    << std::ranges::count(String, ' ') + 1
10    << " words";
11}

1The string has 4 words

Setting the Character Type

Each character in a std::string has the basic char type, but we can change this.

In reality, std::string is nothing more than an alias for another type: std::basic_string<char>.

That means it is simply defining the template type of a std::basic_string, but we can do that ourselves:

1#include <iostream>
2#include <string>
3
4int main(){
5  std::basic_string<char> String{"Hello\n"};
6
7  std::cout << String;
8
9  if constexpr (std::same_as<
10    decltype(String), std::string>) {
11    std::cout << "That was a std::string";
12  }
13}

1Hello
2That was a std::string

As such, we can also use any other character type, not just a basic char. Here, we create a string of "wide" characters, using the wchar_t type.

Before we do this, there are two things to note. First, we cannot initialize "wide" character strings from regular character strings, like a std::string, a char*, or a char[].

Instead, we need to use wide character strings, such as a wchar_t* or wchar_t[]. The language provides a literal for creating these: L"" which we’re using below:

1std::basic_string<wchar_t> String{L"Hello"};

Secondly, we also can’t send wide characters to a stream intended for narrow characters. We need to send them to a stream that accepts wide characters. std::wcout is the wide variation of std::cout

1#include <iostream>
2#include <string>
3
4int main(){
5  std::basic_string<wchar_t> String{L"Hello"};
6  std::wcout << String;
7}

1Hello

We covered "wide" characters in our earlier lesson on Characters:

Characters, Unicode and Encoding

An introduction to C++ character types, the Unicode standard, character encoding, and C-style strings

As an aside, similar to std::string being an alias, most of the std::basic_string variations using other built-in characters have also been aliased to shorter names.

For example, std::basic_string<wchar_t> is available through the alias std::wstring

Memory Management

At this point, the similarities between a std::string and a dynamic array are hopefully clear. The std::string container manages memory in much the same way as a resizable array, such as std::vector.

It occupies a block of memory in which to store its characters.

If that memory is too small to accommodate an action we take, such as appending a load of additional characters, the std::string class takes care of that for us behind the scenes.

It finds a new, larger block of memory to occupy, and it copies all the characters to this new location and then releases its previous memory.

In most cases, we can just ignore that mechanism, but it’s worth spending a moment to understand what’s going on, especially as we can get some performance benefits from intervening.

Similar to std::vector, the std::basic_string types have three methods to investigate the current state of the string’s memory situation:

• size() returns the number of characters that are currently in the string. This is synonymous with the length() method.
• capacity() returns how many characters can be stored before the string needs to reallocate more memory and move to a bigger home
• max_size() is the maximum size the string can grow to, in the current environment. Most actions that would take the string’s size beyond this will throw a std::length_error exception

1#include <iostream>
2#include <string>
3
4int main(){
5  std::string String{"Hello"};
6
7  std::cout << "Size: " << String.size();
8  std::cout << "\nCapacity: "
9    << String.capacity();
10  std::cout << "\nMax Size: "
11    << String.max_size();
12}

1Size: 5
2Capacity: 15
3Max Size: 9223372036854775807

Manipulating the Memory Allocation

Occasionally, we may want to intervene in this process. There are three main methods for doing this

reserve()

The resizing process can be a performance drain. Reallocating memory and moving the characters to the new location takes time.

If we know a string is going to grow through the duration of our program, it can be helpful to just reserve enough space right from the start, reducing the number of reallocations needed.

We can do this by calling the reserve() method, passing a number representing how many characters we want to reserve space for. Our string will be moved to a location that can accommodate that capacity or slightly more:

1#include <iostream>
2#include <string>
3
4int main(){
5  std::string String{"Hello"};
6
7  std::cout << "Capacity: "
8    << String.capacity();
9
10  String.reserve(1'000);
11  std::cout << "\nNew Capacity: "
12    << String.capacity();
13}

1Capacity: 15
2New Capacity: 1007

As of C++20, if the argument we pass to reserve() is lower than the current capacity, the function call has no effect.

With older compilers, it may reduce the capacity() of the string, but not below the size(). That is, it will only reduce excess capacity - existing characters will not be removed.

resize()

The resize() method changes the current size of the string. If the argument we pass to resize() is smaller than the current size, excess characters are pruned:

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

1Hello

If the argument is larger than the current size, we fill the surplus with additional characters. These will be null characters (\0) by default. However, we can pass a second argument to resize() to specify what we want the surplus to be filled with:

1#include <iostream>
2#include <string>
3
4int main(){
5  std::string String{"Hello"};
6  String.resize(10, '!');
7
8  std::cout << String;
9}

1Hello!!!!!

shrink_to_fit()

The shrink_to_fit() function requests that the capacity of the string be reduced to match the size(), or marginally more. This is useful if we no longer expect our string to grow, and we want to release the surplus memory:

1#include <iostream>
2#include <string>
3
4int main(){
5  std::string String;
6  String.reserve(1'000);
7
8  for (int i = 0; i < 100; ++i) {
9    String += "Hello";
10  }
11
12  std::cout << "Size: " << String.
13    size();
14  std::cout << "\nCapacity: " << String.
15    capacity();
16
17  String.shrink_to_fit();
18
19  std::cout << "\n\nSize: " << String.
20    size();
21  std::cout << "\nCapacity: " << String.
22    capacity();
23}

1Size: 500
2Capacity: 1007
3
4Size: 500
5Capacity: 511

Summary

In this lesson, we've explored more of the capabilities of std::string, covering everything from basic modifications to advanced memory management techniques.

Main Points Learned

• How to append content to a std::string using append() and the += operator.
• The use of insert() and insert_range() for adding content at specific positions within a string.
• Removing characters from a string with erase() and its different overloads.
• Replacing parts of a string using replace() and understanding the replace_with_range() function.
• Utilizing std::string iterators and standard library algorithms to manipulate and analyze string content.
• Changing the character type of a std::string to wide characters using std::basic_string<wchar_t>.
• Managing std::string memory with methods like reserve(), resize(), and shrink_to_fit() to optimize performance.

Next Lesson

Regular Expressions

An introduction to regular expressions, and how to use them in C++ with the standard library's regex, regex_match, and regex_search

ContinueView Course