Understanding std::string_view in Modern C++

  • By
  • Posted in C++
  • Updated
  • 2 mins read


With the introduction of C++17, std::string_view was introduced as a lightweight, non-owning reference to a string within the Standard Library. Its primary purpose is to optimize specific operations by eliminating the need for unnecessary string copies and allocations. This article delves into the concept, advantages, and practical applications of std::string_view.

What is std::string_view?

std::string_view is a utility class that provides a view into a string or a contiguous block of characters. Unlike std::string, it does not manage the memory of the string it references. Instead, it simply acts as a pointer to a character array with an associated size. This makes it particularly useful in scenarios where you want to pass or manipulate strings without incurring the overhead of copying or modifying the original string.

Key Features

  • Non-owning Nature: std::string_view does not own the memory it references, making it lightweight and efficient. Any changes to the underlying string will be reflected in the std::string_view.
  • Read-only Access: It provides read-only access to the referenced characters. If you need to modify the string, you should use std::string or other mutable types.
  • Compatibility: It is compatible with C-style strings, std::string, and character arrays.
  • Substrings Made Easy: std::string_view makes creating substrings effortless without copying data.

Benefits of Using std::string_view

  • Improved Performance: By avoiding deep copies of strings, std::string_view enhances performance, especially in functions where strings are passed.
  • Simplicity: It simplifies the code when working with substrings or when passing strings to functions.

Pitfalls and Limitations

  • Lifetime Management: Since std::string_view does not own the memory it references, you must ensure the lifetime of the underlying string exceeds the lifetime of the std::string_view. Using a std::string_view after the referenced string is destroyed results in undefined behavior.
  • Immutable: It does not allow modifying the underlying string. If you need to change the content, use std::string or other mutable types.

Basic Usage

#include <iostream>
#include <string_view>

void print_string(std::string_view sv) {
    std::cout << "String view: " << sv << '\n';
}

int main() {
    // Example 1: Using with std::string
    std::string str = "Hello, World!";
    std::string_view sv = str;
    print_string(sv);

    // Example 2: Using with C-style string
    const char* cstr = "C++ is awesome!";
    std::string_view csv = cstr;
    print_string(csv);

    // Example 3: Substring without copy
    std::string_view sub_sv = sv.substr(7, 5); // "World"
    print_string(sub_sv);

    return 0;
}
Tags: