`basic_string_view` class

Article
10/25/2022

The class template basic_string_view<charT> was added in C++17 to serve as a safe and efficient way for a function to accept various unrelated string types without the function having to be templatized on those types. The class holds a non-owning pointer to a contiguous sequence of character data, and a length that specifies the number of characters in the sequence. No assumption is made about whether the sequence is null-terminated.

The standard library defines several specializations based on the type of the elements:

string_view
wstring_view
u16string_view
u32string_view

A basic_string_view describes the minimum common interface necessary to read string data. It provides const access to the underlying data; it makes no copies (except for the copy function). The data may or may not contain null values (\0) at any position. A basic_string_view has no control over the object's lifetime. It's the caller's responsibility to ensure that the underlying string data is valid.

A function that accepts a parameter of type string_view can be made to work with any string-like type, without making the function into a template, or constraining the function to a particular subset of string types. The only requirement is that an implicit conversion exists from the string type to string_view. All the standard string types are implicitly convertible to a string_view that contains the same element type. In other words, a std::string is convertible to a string_view but not to a wstring_view.

The following example shows a non-template function f that takes a parameter of type wstring_view. It can be called with arguments of type std::wstring, wchar_t*, and winrt::hstring.

// compile with: /std:c++17
// string_view that uses elements of wchar_t
void f(wstring_view);

// pass a std::wstring:
const std::wstring& s { L"Hello" };
f(s);

// pass a C-style null-terminated string (string_view is not null-terminated):
const wchar_t* ns = L"Hello";
f(ns);

// pass a C-style character array of len characters (excluding null terminator):
const wchar_t* cs { L"Hello" };
size_t len { 5 };
f({cs,len});

// pass a WinRT string
winrt::hstring hs { L"Hello" };
f(hs);

Syntax

template <class CharType, class Traits = char_traits<CharType>>
class basic_string_view;

Parameters

CharType
The type of the characters that are stored in the basic_string_view. The C++ Standard Library provides the following typedefs for specializations of this template.

string_view for elements of type char
wstring_view, for wchar_t
u16string_view for char16_t
u32string_view for char32_t.

Traits
Defaults to char_traits<CharType>.

Constructors

Constructor	Description
`basic_string_view`	Constructs a `basic_string_view` that is empty or else points to all or part of some other string object's data, or to a C-style character array.

Typedefs

Type name	Description
`const_iterator`	Random-access iterator that can read `const` elements.
`const_pointer`	`using const_pointer = const value_type*;`
`const_reference`	`using const_reference = const value_type&;`
`const_reverse_iterator`	`using const_reverse_iterator = std::reverse_iterator<const_iterator>;`
`difference_type`	`using difference_type = ptrdiff_t;`
`iterator`	`using iterator = const_iterator;`
`npos`	`static constexpr size_type npos = size_type(-1);`
`pointer`	`using pointer = value_type*;`
`reference`	`using reference = value_type&;`
`reverse_iterator`	`using reverse_iterator = const_reverse_iterator;`
`size_type`	`using size_type = size_t;`
`traits_type`	`using traits_type = Traits;`
`value_type`	`using value_type = CharType;`

Member operators

Operator	Description
`operator=`	Assigns a `basic_string_view` or convertible string object to another `basic_string_view`.
`operator[]`	Returns the element at the specified index.

Member functions

Member function	Description
`at`	Returns a `const_reference` to the element at a specified location.
`back`	Returns a `const_reference` to the last element.
`begin`	Returns a `const` iterator addressing the first element. (`basic_string_view`s are immutable.)
`cbegin`	Same as `begin`.
`cend`	Returns a `const` iterator that points to one past the last element.
`copy`	Copies at most a specified number of characters from an indexed position in a source `basic_string_view` to a target character array. (Not recommended. Use `_Copy_s` instead.)
`_Copy_s`	Secure CRT copy function.
`compare`	Compares a `basic_string_view` with a specified `basic_string_view` to determine if they're equal or if one is lexicographically less than the other.
`crbegin`	Same as `rbegin`.
`crend`	Same as `rend`.
`data`	Returns a raw non-owning pointer to the character sequence.
`empty`	Tests whether the `basic_string_view` contains characters.
`end`	Same as `cend`.
`ends_with`^C++20	Check whether a string view ends with a specified suffix.
`find`	Searches in a forward direction for the first occurrence of a substring that matches a specified sequence of characters.
`find_first_not_of`	Searches for the first character that isn't any element of a specified `basic_string_view` or convertible string object.
`find_first_of`	Searches for the first character that matches any element of a specified `basic_string_view` or convertible string object.
`find_last_not_of`	Searches for the last character that isn't any element of a specified `basic_string_view` or convertible string object.
`find_last_of`	Searches for the last character that is an element of a specified `basic_string_view` or convertible string object.
`front`	Returns a `const_reference` to the first element.
`length`	Returns the current number of elements.
`max_size`	Returns the maximum number of characters a `basic_string_view` could contain.
`rbegin`	Returns a `const` iterator that addresses the first element in a reversed `basic_string_view`.
`remove_prefix`	Moves the pointer forward by the specified number of elements.
`remove_suffix`	Reduces the size of the view by the specified number of elements starting from the back.
`rend`	Returns a `const` iterator that points to one past the last element in a reversed `basic_string_view`.
`rfind`	Searches a `basic_string_view` in reverse for the first occurrence of a substring that matches a specified sequence of characters.
`size`	Returns the current number of elements.
`starts_with`^C++20	Check whether a string view starts with a given prefix.
`substr`	Returns a substring of a specified length starting at a specified index.
`swap`	Exchange the contents of two `basic_string_view` objects.

Remarks

If a function is asked to generate a sequence longer than max_size elements, the function reports a length error by throwing an object of type length_error.

Requirements

std:c++17 or later.

Header: <string_view>

Namespace: std

`basic_string_view::at`

Returns a const_reference to the character at the specified zero-based index.

constexpr const_reference at(size_type offset) const;

Parameters

offset
The index of the element to be referenced.

Return value

A const_reference to the character at the position specified by the parameter index.

Remarks

The first element has an index of zero and the following elements are indexed consecutively by the positive integers, so that a basic_string_view of length n has an *n*th element indexed by the number n - 1. at throws an exception for invalid indices, unlike operator[].

In general, we recommend that at for sequences such as std::vector and basic_string_view should never be used. An invalid index passed to a sequence is a logic error that should be discovered and fixed during development. If a program isn't certain that its indices are valid, it should test them, not call at() and rely on exceptions to defend against careless programming.

For more information, see basic_string_view::operator[].

Example

// basic_string_view_at.cpp
// compile with: /EHsc
#include <string_view>
#include <iostream>

int main()
{
    using namespace std;

    const string_view  str1("Hello world");
    string_view::const_reference refStr2 = str1.at(8); // 'r'
}

`basic_string_view::back`

Returns a const_reference to the last element.

constexpr const_reference back() const;

Return value

A const_reference to the last element in the basic_string_view.

Remarks

Throws an exception if the basic_string_view is empty.

Keep in mind that after a basic_string_view is modified, for example by calling remove_suffix, then the element returned by this function is no longer the last element in the underlying data.

Example

A string_view that is constructed with a C string literal doesn't include the terminating null. So in the following example, back returns 'p' and not '\0'.

char c[] = "Help"; // char[5]
string_view sv{ c };
cout << sv.size(); // size() == 4
cout << sv.back() << endl; // p

Embedded nulls are treated as any other character:

string_view e = "embedded\0nulls"sv;
cout << boolalpha << (e.back() == 's'); // true

`basic_string_view::basic_string_view`

Constructs a basic_string_view.

constexpr basic_string_view() noexcept;
constexpr basic_string_view(const basic_string_view&) noexcept = default;
constexpr basic_string_view(const charT* str);
constexpr basic_string_view(const charT* str, size_type len);

Parameters

str
The pointer to the character values.

len
The number of characters to include in the view.

Remarks

The constructors with a charT* parameter assume that the input is null-terminated, but the terminating null isn't included in the basic_string_view.

You can also construct a basic_string_view with a literal. See operator"" sv.

`basic_string_view::begin`

Same as cbegin.

constexpr const_iterator begin() const noexcept;

Return value

Returns a const_iterator addressing the first element.

`basic_string_view::cbegin`

Returns a const_iterator that addresses the first element in the range.

constexpr const_iterator cbegin() const noexcept;

Return value

A const random-access iterator that points at the first element of the range, or the location just beyond the end of an empty range (for an empty range, cbegin() == cend()).

`basic_string_view::cend`

Returns a const_iterator that addresses the location just beyond the last element in a range.

constexpr const_iterator cend() const noexcept;

Return value

A const random-access iterator that points just beyond the end of the range.

Remarks

The value returned by cend shouldn't be dereferenced.

`basic_string_view::compare`

Does a case-sensitive comparison with a specified basic_string_view (or a convertible string type) to determine if the two objects are equal or if one is lexicographically less than the other. The <string_view> operators use this member function to do comparisons.

constexpr int compare(basic_string_view strv) const noexcept;
constexpr int compare(size_type pos, size_type num, basic_string_view strv) const;
constexpr int compare(size_type pos, size_type num, basic_string_view strv, size_type offset, size_type num2) const;
constexpr int compare(const charT* ptr) const;
constexpr int compare(size_type pos, size_type num, const charT* ptr) const;
constexpr int compare(size_type pos, size_type num, const charT* ptr, size_type num2) const;

Parameters

strv
The basic_string_view that is to be compared to this basic_string_view.

pos
The index of this basic_string_view at which the comparison begins.

num
The maximum number of characters from this basic_string_view to be compared.

num2
The maximum number of characters from strv to be compared.

offset
The index of strv at which the comparison begins.

ptr
The C string to be compared to this basic_string_view.

Return value

A negative value if this basic_string_view is less than strv or ptr
Zero if the two character sequences are equal
A positive value if this basic_string_view is greater than strv or ptr

Remarks

The compare member functions do a case-sensitive comparison of either all or part of each character sequence.

Example

// basic_string_view_compare.cpp
// compile with: /EHsc
#include <string_view>
#include <iostream>
#include <string>

using namespace std;

string to_alpha(int result)
{
   if (result < 0) return " less than ";
   else if (result == 0) return " equal to ";
   else return " greater than ";
}

int main()
{
   // The first member function compares
   // two string_views
   string_view sv_A("CAB");
   string_view sv_B("CAB");
   cout << "sv_A is " << sv_A << endl;
   cout << "sv_B is " << sv_B << endl;
   int comp1 = sv_A.compare(sv_B);
   cout << "sv_A is" << to_alpha(comp1) << "sv_B.\n";

   // The second member function compares part of
   // an operand string_view to another string_view
   string_view sv_C("AACAB");
   string_view sv_D("CAB");
   cout << "sv_C is: " << sv_C << endl;
   cout << "sv_D is: " << sv_D << endl;
   int comp2a = sv_C.compare(2, 3, sv_D);
   cout << "The last three characters of sv_C are"
       << to_alpha(comp2a) << "sv_D.\n";

   int comp2b = sv_C.compare(0, 3, sv_D);
   cout << "The first three characters of sv_C are"
       << to_alpha(comp2b) << "sv_D.\n";

   // The third member function compares part of
   // an operand string_view to part of another string_view
   string_view sv_E("AACAB");
   string_view sv_F("DCABD");
   cout << "sv_E: " << sv_E << endl;
   cout << "sv_F is: " << sv_F << endl;
   int comp3a = sv_E.compare(2, 3, sv_F, 1, 3);
   cout << "The three characters from position 2 of sv_E are"
       << to_alpha(comp3a)
       << "the 3 characters of sv_F from position 1.\n";

   // The fourth member function compares
   // an operand string_view to a C string
   string_view sv_G("ABC");
   const char* cs_A = "DEF";
   cout << "sv_G is: " << sv_G << endl;
   cout << "cs_A is: " << cs_A << endl;
   int comp4a = sv_G.compare(cs_A);
   cout << "sv_G is" << to_alpha(comp4a) << "cs_A.\n";

   // The fifth member function compares part of
   // an operand string_view to a C string
   string_view sv_H("AACAB");
   const char* cs_B = "CAB";
   cout << "sv_H is: " << sv_H << endl;
   cout << "cs_B is: " << cs_B << endl;
   int comp5a = sv_H.compare(2, 3, cs_B);
   cout << "The last three characters of sv_H are"
      << to_alpha(comp5a) << "cs_B.\n";

   // The sixth member function compares part of
   // an operand string_view to part of an equal length of
   // a C string
   string_view sv_I("AACAB");
   const char* cs_C = "ACAB";
   cout << "sv_I is: " << sv_I << endl;
   cout << "cs_C: " << cs_C << endl;
   int comp6a = sv_I.compare(1, 3, cs_C, 3);
   cout << "The 3 characters from position 1 of sv_I are"
      << to_alpha(comp6a) << "the first 3 characters of cs_C.\n";
}

sv_A is CAB
sv_B is CAB
sv_A is equal to sv_B.
sv_C is: AACAB
sv_D is: CAB
The last three characters of sv_C are equal to sv_D.
The first three characters of sv_C are less than sv_D.
sv_E: AACAB
sv_F is: DCABD
The three characters from position 2 of sv_E are equal to the 3 characters of sv_F from position 1.
sv_G is: ABC
cs_A is: DEF
sv_G is less than cs_A.
sv_H is: AACAB
cs_B is: CAB
The last three characters of sv_H are equal to cs_B.
sv_I is: AACAB
cs_C: ACAB
The 3 characters from position 1 of sv_I are equal to the first 3 characters of cs_C.

`basic_string_view::copy`

Copies at most a specified number of characters from an indexed position in a source basic_string_view to a target character array. We recommend that you use the secure function basic_string_view::_Copy_s instead.

size_type copy(charT* ptr, size_type count, size_type offset = 0) const;

Parameters

ptr
The target character array to which the elements are to be copied.

count
The number of characters to be copied, at most, from the source basic_string_view.

offset
The beginning position in the source basic_string_view from which copies are to be made.

Return value

The number of characters copied.

Remarks

A null character isn't appended to the end of the copy.

`basic_string_view::_Copy_s`

Secure CRT copy function to be used instead of copy.

size_type _Copy_s(
    value_type* dest,
    size_type dest_size,
    size_type count,
    size_type _Off = 0) const;

Parameters

dest
The target character array to which the elements are to be copied.

dest_size
The size of dest.

count The number of characters to be copied, at most, from the source string.

_Off
The beginning position in the source string from which copies are to be made.

Return value

The number of characters copied.

Remarks

A null character isn't appended to the end of the copy.

For more information, see c-runtime-library/security-features-in-the-crt.

`basic_string_view::crbegin`

Returns a const_reverse_iterator that addresses the first element in a reversed basic_string_view.

constexpr const_reverse_iterator crbegin() const noexcept;

Return value

A const_reverse_iterator that addresses the first element in a reversed basic_string_view.

`basic_string_view::crend`

Same as rend.

constexpr const_reverse_iterator crend() const noexcept;

Return value

Returns a const_reverse_iterator that addresses one past the end of a reversed basic_string_view.

`basic_string_view::data`

Returns a raw non-owning pointer to the const character sequence of the object that was used to construct the basic_string_view.

constexpr value_type *data() const noexcept;

Return value

A pointer-to-const to the first element of the character sequence.

Remarks

The pointer can't modify the characters.

A sequence of basic_string_view characters isn't necessarily null-terminated. The return type for data isn't a valid C string, because no null character gets appended. The null character \0 has no special meaning in an object of type basic_string_view and may be a part of the basic_string_view object just like any other character.

`basic_string_view::empty`

Tests whether the basic_string_view contains characters or not.

constexpr bool empty() const noexcept;

Return value

true if the basic_string_view object contains no characters; false if it has at least one character.

Remarks

The member function is equivalent to size() == 0.

`basic_string_view::end`

Returns a random-access const_iterator that points to one past the last element.

constexpr const_iterator end() const noexcept;

Return value

Returns a random-access const_iterator that points to one past the last element.

Remarks

end is used to test whether a const_iterator has reached the end of its basic_string_view. The value returned by end shouldn't be dereferenced.

`basic_string_view::ends_with`

Check whether the string view ends with the specified suffix.

bool ends_with(const CharType c) const noexcept;
bool ends_with(const CharType* const x) const noexcept;
bool ends_with(const basic_string_view sv) const noexcept;

Parameters

c
The single character suffix to look for.

sv
A string view containing the suffix to look for.
You can pass a std::basic_string, which converts to a basic_string_view.

x
Null-terminated character string containing the suffix to look for.

Return value

true if the string view ends with the specified suffix; false otherwise.

Remarks

ends_with() is new in C++20. To use it, specify the /std:c++20 or later compiler option.

See starts_with to check if a string view starts with the specified prefix.

Example

// Requires /std:c++20 or /std:c++latest
#include <string>
#include <iostream>

int main()
{
    std::cout << std::boolalpha; // so booleans show as 'true'/'false'  
    std::cout << std::string_view("abcdefg").ends_with('g') << '\n';
    std::cout << std::string_view("abcdefg").ends_with("eFg") << '\n';

    std::basic_string<char> str2 = "efg";
    std::cout << std::string_view("abcdefg").ends_with(str2);

    return 0;
}

true
false
true

`basic_string_view::find`

Searches a basic_string_view in a forward direction for the first occurrence of a character or substring that matches a specified sequence of character(s).

constexpr size_type find(basic_string_view str, size_type offset = 0) const noexcept;
constexpr size_type find(charT chVal, size_type offset = 0) const noexcept;
constexpr size_type find(const charT* ptr, size_type offset, size_type count) const;
constexpr size_type find(const charT* ptr, size_type offset = 0) const;

Parameters

str
The basic_string_view for which the member function is to search.

chVal
The character value for which the member function is to search.

offset
Index at which the search is to begin.

ptr
The C string for which the member function is to search.

count
The number of characters in ptr, counting forward from the first character.

Return value

The index of the first character of the substring searched for when successful; otherwise npos.

`basic_string_view::find_first_not_of`

Searches for the first character that isn't an element of a specified basic_string_view or convertible string object.

constexpr size_type find_first_not_of(basic_string_view str, size_type offset = 0) const noexcept;
constexpr size_type find_first_not_of(charT chVal, size_type offset = 0) const noexcept;
constexpr size_type find_first_not_of(const charT* ptr, size_type offset, size_type count) const;
constexpr size_type find_first_not_of(const charT* ptr, size_type offset = 0) const;

Parameters

str
The basic_string_view for which the member function is to search.

chVal
The character value for which the member function is to search.

offset
Index at which the search is to begin.

ptr
The C string for which the member function is to search.

count
The number of characters, counting forward from the first character, in the C string for which the member function is to search.

Return value

The index of the first character of the substring searched for when successful; otherwise npos.

`basic_string_view::find_first_of`

Searches for the first character that matches any element of a specified basic_string_view.

constexpr size_type find_first_of(basic_string_view str, size_type offset = 0) const noexcept;
constexpr size_type find_first_of(charT chVal, size_type offset = 0) const noexcept;
constexpr size_type find_first_of(const charT* str, size_type offset, size_type count) const;
constexpr size_type find_first_of(const charT* str, size_type offset = 0) const;

Parameters

chVal
The character value for which the member function is to search.

offset
Index at which the search is to begin.

ptr
The C string for which the member function is to search.

count
The number of characters, counting forward from the first character, in the C string for which the member function is to search.

str
The basic_string_view for which the member function is to search.

Return value

The index of the first character of the substring searched for when successful; otherwise npos.

`basic_string_view::find_last_not_of`

Searches for the last character that isn't any element of a specified basic_string_view.

constexpr size_type find_last_not_of(basic_string_view str, size_type offset = npos) const noexcept;
constexpr size_type find_last_not_of(charT chVal, size_type offset = npos) const noexcept;
constexpr size_type find_last_not_of(const charT* ptr, size_type offset, size_type count) const;
constexpr size_type find_last_not_of(const charT* ptr, size_type offset = npos) const;

Parameters

str
The basic_string_view for which the member function is to search.

chVal
The character value for which the member function is to search.

offset
Index at which the search is to finish.

ptr
The C string for which the member function is to search.

count
The number of characters, counting forward from the first character, in ptr.

Return value

The index of the first character of the substring searched for when successful; otherwise string_view::npos.

`basic_string_view::find_last_of`

Searches for the last character that matches any element of a specified basic_string_view.

constexpr size_type find_last_of(basic_string_view str, size_type offset = npos) const noexcept;
constexpr size_type find_last_of(charT chVal, size_type offset = npos) const noexcept;
constexpr size_type find_last_of(const charT* ptr, size_type offset, size_type count) const;
constexpr size_type find_last_of(const charT* ptr, size_type offset = npos) const;

Parameters

str
The basic_string_view for which the member function is to search.

chVal
The character value for which the member function is to search.

offset
Index at which the search is to finish.

ptr
The C string for which the member function is to search.

count
The number of characters, counting forward from the first character, in the C string for which the member function is to search.

Return value

The index of the last character of the substring searched for when successful; otherwise npos.

`basic_string_view::front`

Returns a const_reference to the first element.

constexpr const_reference front() const;

Return value

A const_reference to the first element.

Remarks

Throws an exception if the basic_string_view is empty.

`basic_string_view::length`

Returns the current number of elements.

constexpr size_type length() const noexcept;

Remarks

The member function is the same as size.

`basic_string_view::max_size`

Returns the maximum number of characters a basic_string_view can contain.

constexpr size_type max_size() const noexcept;

Return value

The maximum number of characters a basic_string_view can contain.

Remarks

An exception of type length_error is thrown when an operation produces a basic_string_view with a length greater than max_size().

`basic_string_view::operator=`

Assigns a basic_string_view or convertible string object to another basic_string_view.

constexpr basic_string_view& operator=(const basic_string_view&) noexcept = default;

Example

   string_view s = "Hello";
   string_view s2 = s;

`basic_string_view::operator[]`

Provides a const_reference to the character with a specified index.

constexpr const_reference operator[](size_type offset) const;

Parameters

offset
The index of the element to be referenced.

Return value

A const_reference to the character at the position specified by the parameter index.

Remarks

The first element has an index of zero, and the following elements are indexed consecutively by the positive integers, so that a basic_string_view of length n has an *n*th element indexed by the number n-1.

operator[] is faster than the member function at for providing read access to the elements of a basic_string_view.

operator[] doesn't check whether the index passed as an argument is valid. An invalid index passed to operator[] results in undefined behavior.

The reference returned may be invalidated if the underlying string data is modified or deleted by the owning object.

When compiling with _ITERATOR_DEBUG_LEVEL set to 1 or 2, a runtime error will occur if you attempt to access an element outside the bounds of the basic_string_view. For more information, see Checked Iterators.

`basic_string_view::rbegin`

Returns a const iterator to the first element in a reversed basic_string_view.

constexpr const_reverse_iterator rbegin() const noexcept;

Return value

Returns a random-access iterator to the first element in a reversed basic_string_view, addressing what would be the last element in the corresponding unreversed basic_string_view.

Remarks

rbegin is used with a reversed basic_string_view just as begin is used with a basic_string_view. rbegin can be used to initialize an iteration backwards.

`basic_string_view::remove_prefix`

Moves the pointer forward by the specified number of elements.

constexpr void remove_prefix(size_type n);

Remarks

Leaves the underlying data unchanged. Moves the basic_string_view pointer forward by n elements and sets the private size data member to size - n.

`basic_string_view::remove_suffix`

Reduces the size of the view by the specified number of elements starting from the back.

constexpr void remove_suffix(size_type n);

Remarks

Leaves the underlying data and the pointer to it unchanged. Sets the private size data member to size - n.

`basic_string_view::rend`

Returns a const iterator that points to one past the last element in a reversed basic_string_view.

constexpr reverse_iterator rend() const noexcept;

Return value

A const reverse random-access iterator that points to one past the last element in a reversed basic_string_view.

Remarks

rend is used with a reversed basic_string_view just as end is used with a basic_string_view. rend can be used to test whether a reverse iterator has reached the end of its basic_string_view. The value returned by rend shouldn't be dereferenced.

`basic_string_view::rfind`

Searches a basic_string_view in reverse for a substring that matches a specified sequence of characters.

constexpr size_type rfind(basic_string_view str, size_type offset = npos) const noexcept;
constexpr size_type rfind(charT chVal, size_type offset = npos) const noexcept;
constexpr size_type rfind(const charT* ptr, size_type offset, size_type count) const;
constexpr size_type rfind(const charT* ptr, size_type offset = npos) const;

Parameters

chVal
The character value for which the member function is to search.

offset
Index at which the search is to begin.

ptr
The C string for which the member function is to search.

count
The number of characters, counting forward from the first character, in the C string for which the member function is to search.

str
The basic_string_view for which the member function is to search.

Return value

The index of the first character of the substring when successful; otherwise npos.

`basic_string_view::size`

Returns the number of elements in the basic_string_view.

constexpr size_type size() const noexcept;

Return value

The length of the basic_string_view.

Remarks

A basic_string_view can modify its length, for example by remove_prefix and remove_suffix. Because this doesn't modify the underlying string data, the size of a basic_string_view isn't necessarily the size of the underlying data.

`basic_string_view::starts_with`

Check whether the string view starts with the specified prefix.

bool starts_with(const CharType c) const noexcept;
bool starts_with(const CharType* const x) const noexcept;
bool starts_with(const basic_string_view sv) const noexcept;

Parameters

c
The single character prefix to look for.

sv
A string view containing the prefix to look for.
You can pass a std::basic_string, which converts to a string view.

x
Null-terminated character string containing the prefix to look for.

Return value

true if the string starts with the specified prefix; false otherwise.

Remarks

starts_with() is new in C++20. To use it, specify the std:c++20 or later compiler option.

See ends_with to see if a string ends with a suffix.

Example

// Requires /std:c++20 or /std:c++latest
#include <string>
#include <iostream>

int main()
{
    std::cout << std::boolalpha; // so booleans show as 'true'/'false'  
    std::cout << std::string_view("abcdefg").starts_with('b') << '\n';
    std::cout << std::string_view("abcdefg").starts_with("aBc") << '\n';

    std::basic_string<char> str2 = "abc";
    std::cout << std::string_view("abcdefg").starts_with(str2);

    return 0;
}

false
false
true

`basic_string_view::substr`

Returns a basic_string_view that represents (at most) the specified number of characters from a specified position.

constexpr basic_string_view substr(size_type offset = 0, size_type count = npos) const;

Parameters

offset
An index locating the element at the position from which the copy is made, with a default value of 0.

count
The number of characters to include in the substring, if they're present.

Return value

A basic_string_view object that represents the specified subsequence of elements.

`basic_string_view::swap`

Exchanges two basic_string_views, in other words the pointers to the underlying string data, and the size values.

constexpr void swap(basic_string_view& sv) noexcept;

Parameters

sv
The source basic_string_view whose pointer and size values are to be exchanged with that of the destination basic_string_view.

Share via

basic_string_view class

Syntax

Parameters

Constructors

Typedefs

Member operators

Member functions

Remarks

Requirements

basic_string_view::at

Parameters

Return value

Remarks

Example

basic_string_view::back

Return value

Remarks

Example

basic_string_view::basic_string_view

Parameters

Remarks

basic_string_view::begin

Return value

basic_string_view::cbegin

Return value

basic_string_view::cend

Return value

Remarks

basic_string_view::compare

Parameters

Return value

Remarks

Example

basic_string_view::copy

Parameters

Return value

Remarks

basic_string_view::_Copy_s

Parameters

Return value

Remarks

basic_string_view::crbegin

Return value

basic_string_view::crend

Return value

basic_string_view::data

Return value

Remarks

basic_string_view::empty

Return value

Remarks

basic_string_view::end

Return value

Remarks

basic_string_view::ends_with

Parameters

Return value

Remarks

Example

basic_string_view::find

Parameters

Return value

basic_string_view::find_first_not_of

Parameters

Return value

basic_string_view::find_first_of

Parameters

Return value

basic_string_view::find_last_not_of

Parameters

Return value

basic_string_view::find_last_of

Parameters

Return value

basic_string_view::front

Return value

Remarks

basic_string_view::length

Remarks

`basic_string_view` class

`basic_string_view::at`

`basic_string_view::back`

`basic_string_view::basic_string_view`

`basic_string_view::begin`

`basic_string_view::cbegin`

`basic_string_view::cend`

`basic_string_view::compare`

`basic_string_view::copy`

`basic_string_view::_Copy_s`

`basic_string_view::crbegin`

`basic_string_view::crend`

`basic_string_view::data`

`basic_string_view::empty`

`basic_string_view::end`

`basic_string_view::ends_with`

`basic_string_view::find`

`basic_string_view::find_first_not_of`

`basic_string_view::find_first_of`

`basic_string_view::find_last_not_of`

`basic_string_view::find_last_of`

`basic_string_view::front`

`basic_string_view::length`

`basic_string_view::max_size`

`basic_string_view::operator=`

`basic_string_view::operator[]`

`basic_string_view::rbegin`

`basic_string_view::remove_prefix`

`basic_string_view::remove_suffix`

`basic_string_view::rend`

`basic_string_view::rfind`

`basic_string_view::size`

`basic_string_view::starts_with`

`basic_string_view::substr`

`basic_string_view::swap`