Working with String Views

In this lesson, we expand our knowledge of std::string_view by exploring its methods and operators. This includes working with the individual characters of a string view, analyzing its contents, shrinking its purview, and more.

We also show some practical examples of how string views can interact with other parts of the standard library.

This includes standard library views, algorithms, regular expressions, and anything that works with iterators.

This builds upon our previous introduction to string views, so familiarity with the content covered there is assumed:

String Views

A practical introduction to string views, and why they should be the main way we pass strings to functions

The size() Method

We can retrieve the number of characters in our string view using the size() method:

1#include <iostream>
2
3int main(){
4  std::string_view View{"Hello World"};
5
6  std::cout << "View size: " << View.size();
7}

1View size: 11

Note that the size of the string view is not necessarily the size of the underlying string. The previous lesson showed how we could create a view that only contains part of the string, using the iterator constructor:

1#include <iostream>
2
3int main(){
4  std::string_view String{"Hello World"};
5  std::string_view View{
6    String.begin(), String.begin() + 5};
7
8  std::cout << "String size: " << String.size();
9  std::cout << "\nView size: " << View.size();
10}

1String size: 11
2View size: 5

The remove_suffix() and remove_prefix() methods, which we will cover later in this lesson, also reduce the size of the string view.

Accessing Individual String View Characters

Similar to arrays and other contiguous containers, string views give access to random characters within their purview.

The [] operator

Random character access is typically performed using the [] operator:

1#include <iostream>
2
3int main(){
4  std::string_view View{"Hello World"};
5
6  std::cout << "First: " << View[0]
7    << "\nSecond: " << View[1]
8    << "\nLast: " << View[View.size() - 1];
9}

1First: H
2Second: e
3Last: d

In most implementations, we get bounds checking when using [] if our application is compiled with debug flags. Those checks are then stripped out for release builds, to optimize performance.

The at() method

We can alternatively use at(), which performs run-time bounds checking on our index even in release builds. This has a small performance cost, but throws a std::out_of_range exception if our index is out of bounds:

1#include <iostream>
2
3int main(){
4  std::string_view View{"Hello World"};
5
6  std::cout << "First: " << View.at(0)
7    << "\nSecond: " << View.at(1);
8
9  try {
10    View.at(100);
11  } catch (const std::out_of_range& e) {
12    std::cout << "\nSomething went wrong:\n";
13    std::cout << e.what();
14  }
15}

1First: H
2Second: e
3Something went wrong:
4invalid string_view position

We covered exceptions in a dedicated chapter earlier in the course:

Exceptions: throw, try and catch

This lesson provides an introduction to exceptions, detailing the use of throw, try, and catch.

The front() method

We can access the first character in a string view using the front() method. This is equivalent to View[0]:

1#include <iostream>
2
3int main(){
4  std::string_view View{"Hello World"};
5  std::cout << "Front: " << View.front();
6}

1Front: H

The back() method

The last character in the string view is available using the back() method. This is equivalent to View[View.size() - 1]:

1#include <iostream>
2
3int main(){
4  std::string_view View{"Hello World"};
5  std::cout << "Back: " << View.back();
6}

1Back: d

Comparing String Views

String views implement the full suite of comparison operators:

1#include <iostream>
2#include <string_view>
3
4int main(){
5  std::string_view FruitA{"Apple"};
6  std::string_view FruitB{"Apple"};
7
8  if (FruitA == FruitB) {
9    std::cout << "String views are equal";
10  }
11}

1String views are equal

1#include <iostream>
2#include <string_view>
3
4class Character {
5public:
6  std::string_view Faction;
7};
8
9int main(){
10  Character A{"Human"};
11  Character B{"Human"};
12
13  if (A.Faction == B.Faction) {
14    std::cout << "They're the same faction";
15  }
16}

1They're the same faction

1#include <iostream>
2
3enum class Faction { Human, Elf, Undead };
4
5class Character {
6public:
7  Faction Faction;
8};
9
10int main(){
11  Character A{Faction::Human};
12  Character B{Faction::Human};
13
14  if (A.Faction == B.Faction) {
15    std::cout << "They're the same faction";
16  }
17}

1They're the same faction

Other comparisons, such as < and >= compare string views lexicographically (ie, based on alphabetical order)

1#include <iostream>
2#include <string_view>
3
4int main(){
5  std::string_view Apple{"Apple"};
6  std::string_view Zebra{"Zebra"};
7
8  if (Apple < Zebra) {
9    std::cout << "Apple < Zebra";
10  }
11
12  if (Zebra >= Apple) {
13    std::cout << "\nZebra >= Apple";
14  }
15}

1Apple < Zebra
2Zebra >= Apple

Because of this, collections of string views are directly compatible with algorithms that require the objects they’re acting upon to be orderable. Below, we sort a std::vector of string views into alphabetical order:

1#include <iostream>
2#include <string_view>
3#include <vector>
4#include <algorithm>
5
6int main(){
7  std::vector<std::string_view> Fruits{
8    "Kiwi", "Apple", "Banana"};
9
10  std::ranges::sort(Fruits);
11
12  for (const auto& Fruit : Fruits) {
13    std::cout << Fruit << ", ";
14  }
15}

1Apple, Banana, Kiwi

Analysing String View Contents

String views are compatible with regular expressions and standard library algorithms, which give us a lot of flexibility in analyzing their contents. We’ll cover those later in this lesson, but some of the most common requirements are available as simple built-in methods:

The contains() method

The contains() method returns a boolean representing whether or not the string view contains the specific substring passed as an argument.

1#include <iostream>
2
3int main(){
4  std::string_view Input{"Hello World"};
5
6  if (Input.contains("Hello")) {
7    std::cout << "Greeting Found";
8  }
9}

1Greeting Found

The starts_with() method

The starts_with() method returns a boolean representing whether or not the string view starts with the string provided as an argument.

1#include <iostream>
2
3int main(){
4  std::string_view Input{"Hello World"};
5
6  if (Input.starts_with("Hello")) {
7    std::cout << "Input starts with \"Hello\"";
8  }
9
10  if (!Input.starts_with("World")) {
11    std::cout << "\nBut not \"World\"";
12  }
13}

1Input starts with "Hello"
2But not "World"

The ends_with() method

Finally, the ends_with() method returns true if our string view ends with the provided argument.

1#include <iostream>
2
3int main(){
4  std::string_view Input{"Hello World"};
5
6  if (Input.ends_with("World")) {
7    std::cout << "Input ends with \"World\"";
8  }
9
10  if (Input.contains("Hello")) {
11    std::cout << "\nInput contains \"Hello\"";
12  }
13
14  if (!Input.ends_with("Hello")) {
15    std::cout << " but it's not at the end";
16  }
17}

1Input ends with "World"
2Input contains "Hello" but it's not at the end

Searching String Views

We can search our string views for specific substrings using a range of methods

The find() method

The find() method searches through our string view to find a specific substring. It will then return the index of that substring within our string view:

1#include <iostream>
2
3int main(){
4  std::string_view Input{"Hello world"};
5  size_t Position{Input.find("world")};
6  std::cout << "Position: " << Position;
7}

1Position: 6

If the substring appears multiple times in our string view, find() will return the index of the first occurrence.

If the substring was not found, find() returns a token equal to std::string::npos:

1#include <iostream>
2
3int main(){
4  std::string_view Input{"Hello world"};
5
6  size_t Position{Input.find("goodbye")};
7
8  if (Position == std::string::npos) {
9    std::cout << "That wasn't found";
10  } else {
11    std::cout << "Position: " << Position;
12  }
13}

1That wasn't found

We can pass a second argument to find(), which allows us to customize at what position our search starts. Below, we use this to find both the first and second occurrences of a substring:

1#include <iostream>
2
3int main(){
4  std::string_view Input{
5    "Hello world, goodbye world"};
6
7  size_t First{Input.find("world")};
8  size_t Second{Input.find("world", First + 1)};
9
10  std::cout << "First: " << First
11    << "\nSecond: " << Second;
12}

1First: 6
2Second: 21

The rfind() method

The rfind() method searches the string view in reverse order, returning the position of the last occurrence of the substring:

1#include <iostream>
2
3int main(){
4  std::string_view Input{
5    "Hello world, goodbye world"};
6
7  std::cout
8    << "First: " << Input.find("world")
9    << "\nLast: " << Input.rfind("world");
10}

1First: 6
2Last: 21

Similar to find(), rfind() will return an object equal to std::string::npos if the substring wasn’t found.

We can also pass an additional argument to the function, representing where we want our search to start. Remember, rfind() searches in reverse order, so our search will proceed backward from this position:

1#include <iostream>
2
3int main(){
4  std::string_view Input{
5    "Hello world, goodbye world"};
6
7  size_t Last{Input.rfind("world")};
8  size_t SecondLast{
9    Input.rfind("world", Last - 1)};
10
11  std::cout << "Last: " << Last
12    << "\nSecond Last: " << SecondLast;
13}

1Last: 21
2Second Last: 6

The find_first_of() method

The find_first_of() method accepts a string of characters and returns the index of the first position in our string view that matches any of those characters:

1#include <iostream>
2
3int main(){
4  std::string_view Input{"Hello world"};
5
6  std::cout << "First vowel: "
7    << Input.find_first_of("aeiou");
8}

1First vowel: 1

Similar to find() and rfind(), an object equal to std::string::npos is returned if no matching characters were found:

1#include <iostream>
2
3int main(){
4  std::string_view Input{"Hello world"};
5
6  size_t Position{
7    Input.find_first_of("0123456789")};
8
9  if (Position == std::string::npos) {
10    std::cout << "No numbers found";
11  }
12}

1No numbers found

And we can pass an additional argument to change the position where our search starts:

1#include <iostream>
2
3int main(){
4  std::string_view Input{"Hello world"};
5
6  size_t First{Input.find_first_of("aeiou")};
7  size_t Second{
8    Input.find_first_of("aeiou", First + 1)};
9
10  std::cout
11    << "First Vowel: " << Input[First]
12    << "\nSecond Vowel: " << Input[Second];
13}

1First Vowel: e
2Second Vowel: o

The find_first_not_of() method

The find_first_not_of() method behaves in the same way as find_first_of(), but it will search for the first character that does not match any of the characters in our argument:

1#include <iostream>
2
3int main(){
4  std::string_view Input{"hey"};
5
6  size_t First{
7    Input.find_first_not_of("aeiou")};
8  size_t Second{
9    Input.find_first_not_of("aeiou",
10                            First + 1)};
11  size_t Third{
12    Input.find_first_not_of("aeiou",
13                            Second + 1)};
14
15  std::cout
16    << "First consonant: " << Input[First]
17    << "\nSecond consonant: " << Input[Second];
18
19  if (Third == std::string::npos) {
20    std::cout << "\nThere are no more";
21  }
22}

1First consonant: h
2Second consonant: y
3There are no more

The find_last_of() method

The find_last_of() method has identical behavior to find_first_of(), with the only difference being that the search runs from the end of our string view to the beginning:

1#include <iostream>
2
3int main(){
4  std::string_view Input{"hello"};
5
6  size_t Last{Input.find_last_of("aeiou")};
7  size_t SecondLast{
8    Input.find_last_of("aeiou", Last - 1)};
9  size_t ThirdLast{
10    Input.find_last_of("aeiou",
11                       SecondLast - 1)};
12
13  std::cout
14    << "Last vowel: " << Input[Last]
15    << "\nSecond last vowel: "
16    << Input[SecondLast];
17
18  if (ThirdLast == std::string::npos) {
19    std::cout << "\nThere are no more";
20  }
21}

1Last vowel: o
2Second last vowel: e
3There are no more

The find_last_not_of() method

The find_last_not_of() function behaves similarly to find_first_not_of(). The only exception is that the search starts at the end of our string view and proceeds backward:

1#include <iostream>
2
3int main(){
4  std::string_view Input{"hey"};
5
6  size_t Last{Input.find_last_not_of("aeiou")};
7  size_t SecondLast{
8    Input.find_last_not_of("aeiou", Last - 1)};
9  size_t ThirdLast{
10    Input.find_last_not_of("aeiou",
11                           SecondLast - 1)};
12
13  std::cout
14    << "Last consonant: " << Input[Last]
15    << "\nSecond last consonant: "
16    << Input[SecondLast];
17
18  if (ThirdLast == std::string::npos) {
19    std::cout << "\nThere are no more";
20  }
21}

1Last consonant: y
2Second last consonant: h

String Views and Ranges

String views are ranges, so are compatible with a lot of other language features and standard library utilities. For example, we can use a string view in a range-based for loop, iterating over every character in the string view:

1#include <iostream>
2
3int main(){
4  std::string_view Name{"Anna"};
5
6  for (char C : Name) {
7    std::cout << C << ", ";
8  }
9}

1A, n, n, a,

Iterator and Range-Based Algorithms

An introduction to iterator and range-based algorithms, using examples from the standard library

String Views with Standard Library Algorithms

String views are also compatible with the standard library algorithms we covered earlier in the course. In this example, we use std::ranges::count() to count the number of occurrences of the n character in our string:

1#include <iostream>
2#include <algorithm>
3
4int main(){
5  std::string_view Fruit{"Banana"};
6
7  std::cout << "Number of 'n's: " <<
8    std::ranges::count(Fruit, 'n');
9}

1Number of 'n's: 2

String Views with Standard Library Views

We can also use our string views in conjunction with other views. We covered standard library views earlier in the course:

Standard Library Views

Learn how to create and use views in C++ using examples from std::views

In this example, we use std::ranges::take() to create a view of only the first 3 characters:

1#include <iostream>
2#include <ranges>
3
4int main(){
5  std::string_view Name{"Anna"};
6
7  for (char C : std::views::take(Name, 3)) {
8    std::cout << C << ", ";
9  }
10}

1A, n, n,

Below, we have a more complex example that uses std::views::zip() and std::views::iota() to generate a more complex output:

1#include <iostream>
2#include <ranges>
3
4int main(){
5  using std::views::iota, std::views::zip;
6  std::string_view Name{"Anna"};
7
8  for (auto T : zip(iota(1), Name)) {
9    std::cout << "Character "
10      << std::get<0>(T) << ": "
11      << std::get<1>(T) << '\n';
12  }
13}

1Character 1: A
2Character 2: n
3Character 3: n
4Character 4: a

String View Iterators and Subranges

String views support the usual collection of iterators, making them widely interoperable with other aspects of the standard library. Below, we use these iterators to create a std::ranges::subrange() that views part of the string view:

1#include <algorithm>
2#include <iostream>
3
4int main(){
5  std::string_view Name{"Anna"};
6
7  std::ranges::subrange Subrange{
8    Name.begin(), Name.begin() + 3};
9
10  for (char C : Subrange) {
11    std::cout << C << ", ";
12  }
13}

1A, n, n,

Rather than creating a subrange from a string view, we also have the option to create another string view.

Using the iterator constructor, we can constrict this second string view to contain only a subset of the original characters:

1#include <iostream>
2
3int main(){
4  std::string_view Name{"Anna"};
5
6  std::string_view Subview{
7    Name.begin(), Name.begin() + 3};
8
9  for (char C : Subview) {
10    std::cout << C << ", ";
11  }
12}

1A, n, n,

This is similar to the previous example, but our new object is now a std::string_view rather than a std::ranges::subrange

Shrinking a String View In Place

We can constrain a string view in place, using the remove_prefix() and remove_suffix() methods. These remove characters from the start of the view and the end of the view respectively. We pass an integer argument, representing how many characters we want to remove:

1#include <iostream>
2
3int main(){
4  std::string_view View{"--Hello-"};
5  std::cout << "View: " << View;
6
7  View.remove_suffix(1);
8  std::cout << "\nView: " << View;
9
10  View.remove_prefix(2);
11  std::cout << "\nView: " << View;
12}

1View: --Hello-
2View: --Hello
3View: Hello

Remember, a string view is simply a view of an underlying string. Reducing the extent of the view does not modify the underlying string - it just changes the part of the string that is being viewed.

1#include <iostream>
2
3int main(){
4  std::string Name{"Anna"};
5  std::string_view View{Name};
6
7  View.remove_prefix(1);
8  View.remove_suffix(1);
9
10  std::cout << "String: " << Name;
11  std::cout << "\nView: " << View;
12}

1String: Anna
2View: nn

Copying Characters from a String View

We can copy the contents of our string view to another character array, using a raw pointer. The copy() method accepts three arguments:

• A raw pointer to the character array
• The number of characters we want to copy
• The position of the first character we want to copy from. This is an optional parameter defaulted to 0

We should ensure our pointer points at a memory location with enough space to receive the characters we will be copying to it.

In this example, we assemble a char* containing the contents "Hello World!" using the characters from string views:

1#include <iostream>
2
3int main(){
4  std::string_view InputA{"Hello"};
5  std::string_view InputB{" World"};
6  std::string_view InputC{"Nice!"};
7  char Output[13]{"------------"};
8
9  std::cout << Output;
10
11  // Copy 5 characters from InputA to Output
12  InputA.copy(Output, 5);
13  std::cout << '\n' << Output;
14
15  // Copy 6 characters from InputB to Output
16  // Starting at Output[6]
17  InputB.copy(Output + 5, 6);
18  std::cout << '\n' << Output;
19
20  // Copy 1 character from InputC to Output
21  // Starting at InputC[4] and Output[12]
22  InputC.copy(Output + 11, 1, 4);
23  std::cout << '\n' << Output;
24}

1------------
2Hello-------
3Hello World-
4Hello World!

Using Regular Expressions with String Views

The standard library’s regular expression utilities have limited support for string views, but we do have some options. These options typically involve using the constructors and methods that accept iterators.

Below, we check if our string view contains the pattern "hello", without respecting capitalization. Effectively, this is an alternative to the contains() method when we want our search to be case-insensitive:

1#include <iostream>
2#include <regex>
3
4int main(){
5  std::string_view Input{"Hello world"};
6
7  std::regex Pattern("hello",
8                     std::regex_constants::icase);
9
10  bool MatchResult{
11    std::regex_search(Input.begin(),
12                      Input.end(),
13                      Pattern)};
14
15  if (MatchResult) {
16    std::cout << "Greeting found";
17  }
18}

1Greeting found

In this example, we check if our string view contains either "hello" or "hi":

1#include <iostream>
2#include <regex>
3
4int main(){
5  std::string_view Input{"hello world"};
6
7  bool MatchResult{
8    std::regex_search(Input.begin(),
9                      Input.end(),
10                      std::regex("hello|hi"))};
11
12  if (MatchResult) {
13    std::cout << "Greeting found";
14  }
15}

1Greeting found

We have dedicated lessons on regular expressions and the flexibility they give us here:

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

Regex Capture Groups

An introduction to regular expression capture groups, and how to use them in C++ with regex search, replace, iterator, and token_iterator

Summary

In this lesson, we explored std::string_view, demonstrating how it can be used to view and manipulate strings without owning them. We covered a range of methods and operations that make std::string_view a powerful tool for working with strings in a performant and flexible manner.

Main Points Learned

• The functionality and use cases of std::string_view methods such as size(), remove_suffix(), and remove_prefix().
• How to access individual characters in a string view using the [] operator and the at() method, including bounds checking with at().
• The process of comparing string views using comparison operators and the importance of efficient string comparison techniques.
• Various methods for analyzing string view contents, including contains(), starts_with(), and ends_with().
• Techniques for searching within string views using find(), rfind(), find_first_of(), and related methods.
• The compatibility of string views with standard library algorithms and views demonstrates their use in range-based for loops and with algorithms like std::ranges::count().
• How to work with string views and regular expressions for pattern matching, utilizing iterator-based methods for compatibility.
• Practical examples of modifying string views in place using remove_prefix() and remove_suffix(), and the implications of viewing versus owning string data.
• Copying characters from a string view to another character array using the copy() method.

Next Lesson

Output Streams

A detailed overview of C++ Output Streams, from basics and key functions to error handling and custom types.

ContinueView Course