Standard library header <string_view> (C++17)

From cppreference.com

Compiler support
Freestanding and hosted
Language
Standard library
Standard library headers
Named requirements
Feature test macros(C++20)
Language support library
Concepts library(C++20)
Diagnostics library
Memory management library
Metaprogramming library(C++11)
General utilities library
Containers library
Iterators library
Ranges library(C++20)
Algorithms library
Strings library
Text processing library
Numerics library
Date and time library
Input/output library
Filesystem library(C++17)
Concurrency support library(C++11)
Execution control library(C++26)
Technical specifications
Symbols index
External libraries

[edit]

Standard library headers

Language support
`<cfloat>`
`<climits>`
`<compare>`(C++20)
`<contracts>`(C++26)
`<coroutine>`(C++20)
`<csetjmp>`
`<csignal>`
`<cstdarg>`
`<cstddef>`
`<cstdint>`(C++11)
`<cstdlib>`
`<exception>`
`<initializer_list>`(C++11)
`<limits>`
`<new>`
`<source_location>`(C++20)
`<stdfloat>`(C++23)
`<typeinfo>`
`<version>`(C++20)
Concepts
`<concepts>`(C++20)
Diagnostics
`<cassert>`
`<cerrno>`
`<debugging>`(C++26)
`<stacktrace>`(C++23)
`<stdexcept>`
`<system_error>`(C++11)
Memory management
`<memory>`
`<memory_resource>`(C++17)
`<scoped_allocator>`(C++11)
Metaprogramming
`<type_traits>`(C++11)
`<ratio>`(C++11)

General utilities
`<any>`(C++17)
`<bitset>`
`<bit>`(C++20)
`<charconv>`(C++17)
`<expected>`(C++23)
`<format>`(C++20)
`<functional>`
`<optional>`(C++17)
`<stdbit.h>`(C++26)
`<tuple>`(C++11)
`<typeindex>`(C++11)
`<utility>`
`<variant>`(C++17)
Containers
`<array>`(C++11)
`<deque>`
`<flat_map>`(C++23)
`<flat_set>`(C++23)
`<forward_list>`(C++11)
`<hive>`(C++26)
`<inplace_vector>`(C++26)
`<list>`
`<map>`
`<mdspan>`(C++23)
`<queue>`
`<set>`
`<span>`(C++20)
`<stack>`
`<unordered_map>`(C++11)
`<unordered_set>`(C++11)
`<vector>`
Iterators
`<iterator>`
Ranges
`<generator>`(C++23)
`<ranges>`(C++20)

Algorithms
`<algorithm>`
`<numeric>`
Strings
`<cctype>`
`<cstring>`
`<cuchar>`(C++11)
`<cwchar>`
`<cwctype>`
`<string_view>`(C++17)
`<string>`
Text processing
`<clocale>`
`<codecvt>`(C++11/17/26*)
`<locale>`
`<regex>`(C++11)
`<text_encoding>`(C++26)
Numerics
`<cfenv>`(C++11)
`<cmath>`
`<complex>`
`<linalg>`(C++26)
`<numbers>`(C++20)
`<random>`(C++11)
`<simd>`(C++26)
`<stdckdint.h>`(C++26)
`<valarray>`
Time
`<chrono>`(C++11)
`<ctime>`
C compatibility
`<ccomplex>`(C++11/17/20*)
`<ciso646>`(until C++20)
`<cstdalign>`(C++11/17/20*)
`<cstdbool>`(C++11/17/20*)
`<ctgmath>`(C++11/17/20*)

Input/output
`<cinttypes>`(C++11)
`<cstdio>`
`<filesystem>`(C++17)
`<fstream>`
`<iomanip>`
`<iosfwd>`
`<iostream>`
`<ios>`
`<istream>`
`<ostream>`
`<print>`(C++23)
`<spanstream>`(C++23)
`<sstream>`
`<streambuf>`
`<strstream>`(C++98/26*)
`<syncstream>`(C++20)
Concurrency support
`<atomic>`(C++11)
`<barrier>`(C++20)
`<condition_variable>`(C++11)
`<future>`(C++11)
`<hazard_pointer>`(C++26)
`<latch>`(C++20)
`<mutex>`(C++11)
`<rcu>`(C++26)
`<semaphore>`(C++20)
`<shared_mutex>`(C++14)
`<stdatomic.h>`(C++23)
`<stop_token>`(C++20)
`<thread>`(C++11)
Execution support
`<execution>`(C++17)

[edit]

This header is part of thestrings library.

Includes

(C++20)

Three-way comparison operator support[edit]

Classes

basic_string_view

(C++17)

read-only string view
(class template)[edit]

std::string_view(C++17) std::basic_string_view<char>

std::u8string_view(C++20) std::basic_string_view<char8_t>

std::u16string_view(C++17) std::basic_string_view<char16_t>

std::u32string_view(C++17) std::basic_string_view<char32_t>

std::wstring_view(C++17) std::basic_string_view<wchar_t>

std::hash<std::string_view>std::hash<std::wstring_view>std::hash<std::u8string_view>std::hash<std::u16string_view>std::hash<std::u32string_view>

(C++17)(C++17)(C++20)(C++17)(C++17)

hash support for string views
(class template specialization)[edit]

Forward declarations

Defined in header<functional>

hash

(C++11)

hash function object
(class template)[edit]

Functions

operator==operator!=operator<operator>operator<=operator>=operator<=>

(C++17)(removed in C++20)(removed in C++20)(removed in C++20)(removed in C++20)(removed in C++20)(C++20)

lexicographically compares two string views
(function template)[edit]

operator<<

(C++17)

performs stream output on string views
(function template)[edit]

swap

swaps the values of two objects
(function template)[edit]

Range access

begincbegin

(C++11)(C++14)

returns an iterator to the beginning of a container or array
(function template)[edit]

endcend

(C++11)(C++14)

returns an iterator to the end of a container or array
(function template)[edit]

rbegincrbegin

(C++14)

returns a reverse iterator to the beginning of a container or array
(function template)[edit]

rendcrend

(C++14)

returns a reverse end iterator for a container or array
(function template)[edit]

sizessize

(C++17)(C++20)

returns the size of a container or array
(function template)[edit]

empty

(C++17)

checks whether the container is empty
(function template)[edit]

data

(C++17)

obtains the pointer to the underlying array
(function template)[edit]

Literals

Defined in inline namespacestd::literals::string_view_literals

operator""sv

(C++17)

creates a string view of a character array literal
(function)[edit]

[edit]Synopsis

#include <compare> namespace std{// class template basic_string_viewtemplate<class CharT,class Traits= char_traits<CharT>>class basic_string_view; template<class CharT,class Traits>inlineconstexprboolranges::enable_view<basic_string_view<CharT, Traits>>=true;template<class CharT,class Traits>inlineconstexprboolranges::enable_borrowed_range<basic_string_view<CharT, Traits>>=true; // non-member comparison functionstemplate<class CharT,class Traits>constexprbool operator==(basic_string_view<CharT, Traits> x,                              basic_string_view<CharT, Traits> y)noexcept;template<class CharT,class Traits>constexpr/* see description */      operator<=>(basic_string_view<CharT, Traits> x,                  basic_string_view<CharT, Traits> y)noexcept; // sufficient additional overloads of comparison functions // inserters and extractorstemplate<class CharT,class Traits>    basic_ostream<CharT, Traits>&      operator<<(basic_ostream<CharT, Traits>& os,                 basic_string_view<CharT, Traits> str); // basic_string_view typedef namesusing string_view= basic_string_view<char>;using u8string_view= basic_string_view<char8_t>;using u16string_view= basic_string_view<char16_t>;using u32string_view= basic_string_view<char32_t>;using wstring_view= basic_string_view<wchar_t>; // hash supporttemplate<class T>struct hash;template<>struct hash<string_view>;template<>struct hash<u8string_view>;template<>struct hash<u16string_view>;template<>struct hash<u32string_view>;template<>struct hash<wstring_view>; inlinenamespace literals{inlinenamespace string_view_literals{// suffix for basic_string_view literalsconstexpr string_view    operator""sv(constchar* str, size_t len)noexcept;constexpr u8string_view  operator""sv(const char8_t* str, size_t len)noexcept;constexpr u16string_view operator""sv(constchar16_t* str, size_t len)noexcept;constexpr u32string_view operator""sv(constchar32_t* str, size_t len)noexcept;constexpr wstring_view   operator""sv(constwchar_t* str, size_t len)noexcept;}}}

[edit]Class templatestd::basic_string_view

namespace std{template<class CharT,class Traits= char_traits<CharT>>class basic_string_view{public:// typesusing Traits_type= Traits;using value_type= CharT;using pointer= value_type*;using const_pointer=const value_type*;using reference= value_type&;using const_reference=const value_type&;using const_iterator=/* implementation-defined */using iterator= const_iterator;using const_reverse_iterator= reverse_iterator<const_iterator>;using reverse_iterator= const_reverse_iterator;using size_type= size_t;using difference_type= ptrdiff_t;staticconstexpr size_type npos= size_type(-1); // construction and assignmentconstexpr basic_string_view()noexcept;constexpr basic_string_view(const basic_string_view&)noexcept=default;constexpr basic_string_view& operator=(const basic_string_view&)noexcept=default;constexpr basic_string_view(const CharT* str);constexpr basic_string_view(nullptr_t)= delete;constexpr basic_string_view(const CharT* str, size_type len);template<class It,class End>constexpr basic_string_view(It begin, End end);template<class R>constexprexplicit basic_string_view(R&& r); // iterator supportconstexpr const_iterator begin()constnoexcept;constexpr const_iterator end()constnoexcept;constexpr const_iterator cbegin()constnoexcept;constexpr const_iterator cend()constnoexcept;constexpr const_reverse_iterator rbegin()constnoexcept;constexpr const_reverse_iterator rend()constnoexcept;constexpr const_reverse_iterator crbegin()constnoexcept;constexpr const_reverse_iterator crend()constnoexcept; // capacityconstexpr size_type size()constnoexcept;constexpr size_type length()constnoexcept;constexpr size_type max_size()constnoexcept;constexprbool empty()constnoexcept; // element accessconstexpr const_reference operator[](size_type pos)const;constexpr const_reference at(size_type pos)const;constexpr const_reference front()const;constexpr const_reference back()const;constexpr const_pointer data()constnoexcept; // modifiersconstexprvoid remove_prefix(size_type n);constexprvoid remove_suffix(size_type n);constexprvoid swap(basic_string_view& s)noexcept; // string operationsconstexpr size_type copy(CharT* s, size_type n, size_type pos=0)const; constexpr basic_string_view substr(size_type pos=0, size_type n= npos)const; constexprint compare(basic_string_view s)constnoexcept;constexprint compare(size_type pos1, size_type n1, basic_string_view s)const;constexprint compare(size_type pos1, size_type n1, basic_string_view s,                          size_type pos2, size_type n2)const;constexprint compare(const CharT* s)const;constexprint compare(size_type pos1, size_type n1,const CharT* s)const;constexprint compare(size_type pos1, size_type n1,const CharT* s,                          size_type n2)const; constexprbool starts_with(basic_string_view x)constnoexcept;constexprbool starts_with(CharT x)constnoexcept;constexprbool starts_with(const CharT* x)const;constexprbool ends_with(basic_string_view x)constnoexcept;constexprbool ends_with(CharT x)constnoexcept;constexprbool ends_with(const CharT* x)const; constexprbool contains(basic_string_view x)constnoexcept;constexprbool contains(CharT x)constnoexcept;constexprbool contains(const CharT* x)const; // searchingconstexpr size_type find(basic_string_view s, size_type pos=0)constnoexcept;constexpr size_type find(CharT c, size_type pos=0)constnoexcept;constexpr size_type find(const CharT* s, size_type pos, size_type n)const;constexpr size_type find(const CharT* s, size_type pos=0)const;constexpr size_type rfind(basic_string_view s, size_type pos= npos)constnoexcept;constexpr size_type rfind(CharT c, size_type pos= npos)constnoexcept;constexpr size_type rfind(const CharT* s, size_type pos, size_type n)const;constexpr size_type rfind(const CharT* s, size_type pos= npos)const; constexpr size_type find_first_of(basic_string_view s,                                      size_type pos=0)constnoexcept;constexpr size_type find_first_of(CharT c, size_type pos=0)constnoexcept;constexpr size_type find_first_of(const CharT* s, size_type pos, size_type n)const;constexpr size_type find_first_of(const CharT* s, size_type pos=0)const;constexpr size_type find_last_of(basic_string_view s,                                     size_type pos= npos)constnoexcept;constexpr size_type find_last_of(CharT c, size_type pos= npos)constnoexcept;constexpr size_type find_last_of(const CharT* s, size_type pos, size_type n)const;constexpr size_type find_last_of(const CharT* s, size_type pos= npos)const;constexpr size_type find_first_not_of(basic_string_view s,                                          size_type pos=0)constnoexcept;constexpr size_type find_first_not_of(CharT c, size_type pos=0)constnoexcept;constexpr size_type find_first_not_of(const CharT* s, size_type pos,                                          size_type n)const;constexpr size_type find_first_not_of(const CharT* s, size_type pos=0)const;constexpr size_type find_last_not_of(basic_string_view s,                                       size_type pos= npos)constnoexcept;constexpr size_type find_last_not_of(CharT c, size_type pos= npos)constnoexcept;constexpr size_type find_last_not_of(const CharT* s, size_type pos,                                         size_type n)const;constexpr size_type find_last_not_of(const CharT* s, size_type pos= npos)const; private:    const_pointer data_;// exposition only    size_type size_;// exposition only}; // deduction guidestemplate<class It,class End>    basic_string_view(It, End)-> basic_string_view<iter_value_t<It>>; template<class R>    basic_string_view(R&&)-> basic_string_view<ranges::range_value_t<R>>;}