Třída basic_string_view

Šablona basic_string_view<charT> třídy byla přidána v jazyce C++17, která slouží jako bezpečný a efektivní způsob, jak funkce přijímat různé nesouvisející typy řetězců, aniž by funkce musela být na těchto typech šablonována. Třída obsahuje nevlastní ukazatel na souvislou sekvenci dat znaků a délku, která určuje počet znaků v sekvenci. Nedochází k žádnému předpokladu, jestli je sekvence ukončena hodnotou null.

Standardní knihovna definuje několik specializace na základě typu prvků:

• string_view
• wstring_view
• u16string_view
• u32string_view

A basic_string_view popisuje minimální společné rozhraní potřebné ke čtení řetězcových dat. Poskytuje přístup k podkladovým datům; neprovádí žádné kopie (s výjimkou copy funkce). Data mohou nebo nesmí obsahovat hodnoty null (\0) na žádné pozici. A basic_string_view nemá žádnou kontrolu nad životností objektu. Je zodpovědností volajícího zajistit, aby podkladová řetězcová data byla platná.

Funkci, která přijímá parametr typu string_view , lze provést tak, aby fungovala s libovolným typem typu podobnému řetězci, aniž by funkce byla v šabloně nebo omezena na konkrétní podmnožinu typů řetězců. Jediným požadavkem je, že implicitní převod existuje z typu řetězce na string_view. Všechny standardní typy řetězců jsou implicitně konvertibilní na string_view typ, který obsahuje stejný typ prvku. Jinými slovy, std::string je kabriolet na , string_view ale ne na wstring_view.

Následující příklad ukazuje funkci f bez šablony, která přebírá parametr typu wstring_view. Lze ji volat pomocí argumentů typu std::wstring, wchar_t*a 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);

Syntaxe

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

Parametry

CharType
Typ znaků, které jsou uloženy v souboru basic_string_view. Standardní knihovna jazyka C++ poskytuje následující definice typů pro specializace této šablony.

• string_view pro prvky typu char
• wstring_viewPro wchar_t
• u16string_view pro char16_t
• u32string_view pro char32_t.

Traits
Výchozí hodnota char_traits<CharType>je .

Konstruktory

Konstruktor	Popis
basic_string_view	Vytvoří prázdnou nebo jinou basic_string_view hodnotu, která odkazuje na všechna nebo část dat jiného objektu řetězce nebo na pole znaků ve stylu jazyka C.

Typedefs

Název typu	Popis
const_iterator	Iterátor s náhodným přístupem, který může číst const prvky.
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;

Operátory členů

Operátor	Popis
operator=	basic_string_view Přiřadí objekt řetězce nebo sklápěcí objekt jinému basic_string_view.
operator[]	Vrátí prvek v zadaném indexu.

Členské funkce

Členová funkce	Popis
at	const_reference Vrátí prvek v zadaném umístění.
back	const_reference Vrátí poslední prvek.
begin	const Vrátí iterátor adresování prvního prvku. (basic_string_views jsou neměnné.)
cbegin	Stejné jako begin.
cend	const Vrátí iterátor, který odkazuje na jeden po posledním prvku.
copy	Zkopíruje maximálně zadaný počet znaků z indexované pozice ve zdroji basic_string_view do cílového pole znaků. (Nedoporučuje se. Použijte _Copy_s místo toho.)
_Copy_s	Zabezpečená funkce kopírování CRT
compare	Porovná zadanou basic_string_viewbasic_string_view hodnotu, která určí, jestli jsou rovny nebo jestli je jedna lexikálně menší než druhá.
crbegin	Stejné jako rbegin.
crend	Stejné jako rend.
data	Vrátí nezpracovaný nevlastní ukazatel na sekvenci znaků.
empty	Testuje, zda basic_string_view obsahuje znaky.
end	Stejné jako cend.
ends_withC++20	Zkontrolujte, jestli zobrazení řetězců končí zadanou příponou.
find	Vyhledá první výskyt podřetětěce, který odpovídá zadané sekvenci znaků, ve směru dopředu.
find_first_not_of	Vyhledá první znak, který není žádným prvkem zadaného basic_string_view nebo konvertibilního objektu řetězce.
find_first_of	Vyhledá první znak, který odpovídá libovolnému prvku zadaného basic_string_view nebo konvertibilního objektu řetězce.
find_last_not_of	Vyhledá poslední znak, který není žádným prvkem zadaného basic_string_view nebo konvertibilního objektu řetězce.
find_last_of	Vyhledá poslední znak, který je prvkem zadaného basic_string_view nebo konvertibilního objektu řetězce.
front	Vrátí hodnotu const_reference k prvnímu prvku.
length	Vrátí aktuální počet prvků.
max_size	Vrátí maximální počet znaků, které basic_string_view může obsahovat.
rbegin	const Vrátí iterátor, který řeší první prvek v obráceném směru basic_string_view.
remove_prefix	Přesune ukazatel dopředu o zadaný počet prvků.
remove_suffix	Zmenšuje velikost zobrazení podle zadaného počtu prvků, které začínají od pozadí.
rend	const Vrátí iterátor, který odkazuje na poslední prvek v obráceném směru basic_string_view.
rfind	Vyhledá obráceně basic_string_view první výskyt podřetětěce, který odpovídá zadané sekvenci znaků.
size	Vrátí aktuální počet prvků.
starts_withC++20	Zkontrolujte, jestli zobrazení řetězců začíná danou předponou.
substr	Vrátí podřetězdí zadanou délku počínaje zadaným indexem.
swap	Vyměňte obsah dvou basic_string_view objektů.

Poznámky

Pokud je funkce požádána o vygenerování sekvence delší než max_size prvky, funkce hlásí chybu délky vyvoláním objektu typu length_error.

Požadavky

std:c++17 nebo novější.

Záhlaví:<string_view>

Obor názvů:std

basic_string_view::at

const_reference Vrátí znak na zadaném indexu založeném na nule.

constexpr const_reference at(size_type offset) const;

Parametry

offset
Index prvku, na který se má odkazovat.

Vrácená hodnota

Znak na const_reference pozici určené indexem parametru.

Poznámky

První prvek má index nuly a následující prvky jsou indexovány po sobě kladnými celými čísly, takže basic_string_view délka má *n*th prvek indexovaný číslem n - 1n . at vyvolá výjimku pro neplatné indexy, na rozdíl od operator[].

Obecně doporučujeme, aby at se sekvence std::vector jako a basic_string_view nikdy neměly používat. Neplatný index předaný sekvenci je logická chyba, která by se měla zjistit a opravit během vývoje. Pokud si program není jistý, že jsou jeho indexy platné, měl by je otestovat, ne volat at() a spoléhat se na výjimky, které se mají bránit proti neopatrné programování.

Další informace najdete na webu basic_string_view::operator[].

Příklad

// 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

const_reference Vrátí poslední prvek.

constexpr const_reference back() const;

Vrácená hodnota

A const_reference až k poslednímu prvku v objektu basic_string_view.

Poznámky

Vyvolá výjimku, pokud basic_string_view je prázdná.

Mějte na paměti, že po basic_string_view změně, například voláním remove_suffix, pak prvek vrácený touto funkcí již není posledním prvkem v podkladových datech.

Příklad

Hodnota string_view , která je vytvořena pomocí řetězcového literálu jazyka C, neobsahuje ukončující hodnotu null. V následujícím příkladu tedy back vrátí a 'p' ne '\0'.

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

Vložené hodnoty null se považují za jakýkoli jiný znak:

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

basic_string_view::basic_string_view

Vytvoří .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);

Parametry

str
Ukazatel na hodnoty znaků.

len
Počet znaků, které se mají zahrnout do zobrazení.

Poznámky

Konstruktory s parametrem charT* předpokládají, že vstup je ukončen s hodnotou null, ale ukončující hodnota null není zahrnuta basic_string_viewv souboru .

Můžete také vytvořit basic_string_view literál s literálem. Viz třída operator"" sv.

basic_string_view::begin

Stejné jako cbegin.

constexpr const_iterator begin() const noexcept;

Vrácená hodnota

Vrátí adresování const_iterator prvního prvku.

basic_string_view::cbegin

Vrátí hodnotu const_iterator , která řeší první prvek v oblasti.

constexpr const_iterator cbegin() const noexcept;

Vrácená hodnota

const Iterátor náhodného přístupu, který odkazuje na první prvek oblasti nebo umístění těsně za koncem prázdné oblasti (pro prázdnou oblast, cbegin() == cend()).

basic_string_view::cend

const_iterator Vrátí adresu, která se zabývá umístěním za posledním prvkem v rozsahu.

constexpr const_iterator cend() const noexcept;

Vrácená hodnota

const Iterátor náhodného přístupu, který odkazuje těsně za koncem rozsahu.

Poznámky

Hodnota vrácená cend by neměla být dereferenced.

basic_string_view::compare

Porovnává rozlišování velkých a velkých písmen se zadaným basic_string_view (nebo konvertibilním typem řetězce), aby bylo možné určit, jestli jsou tyto dva objekty stejné nebo jestli je jeden lexikograficky menší než druhý. Operátory <string_view> používají tuto člennou funkci k porovnání.

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;

Parametry

strv
To basic_string_view je třeba porovnat s tímto basic_string_view.

pos
Index toho basic_string_view , ve kterém začíná porovnání.

num
Maximální početznakůch basic_string_view

num2
Maximální počet znaků, ze strv které se má porovnat.

offset
Index, na strv kterém začíná porovnání.

ptr
Řetězec jazyka C, který se má porovnat s tímto basic_string_viewřetězcem .

Vrácená hodnota

• Záporná hodnota, pokud je tato basic_string_view hodnota menší nebo strvptr
• Nula, pokud jsou dvě sekvence znaků stejné
• Kladná hodnota, pokud je tato basic_string_view hodnota větší nebo strvptr

Poznámky

Členské compare funkce porovnávají malá a velká písmena u všech nebo částí každé sekvence znaků.

Příklad

// 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

Zkopíruje maximálně zadaný počet znaků z indexované pozice ve zdroji basic_string_view do cílového pole znaků. Doporučujeme místo toho použít zabezpečenou funkci basic_string_view::_Copy_s .

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

Parametry

ptr
Cílové pole znaků, do kterého se mají prvky zkopírovat.

count
Maximální počet znaků, které se mají zkopírovat ze zdroje basic_string_view.

offset
Počáteční pozice ve zdroji basic_string_view , ze kterého se mají vytvořit kopie.

Vrácená hodnota

Počet zkopírovaných znaků.

Poznámky

Na konec kopie není připojen znak null.

basic_string_view::_Copy_s

Zabezpečená funkce kopírování CRT, která se použije místo copy.

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

Parametry

dest
Cílové pole znaků, do kterého se mají prvky zkopírovat.

dest_size
Velikost dest.

count Maximální počet znaků, které se mají zkopírovat ze zdrojového řetězce.

_Off
Počáteční pozice ve zdrojovém řetězci, ze kterého se mají vytvořit kopie.

Vrácená hodnota

Počet zkopírovaných znaků.

Poznámky

Na konec kopie není připojen znak null.

Další informace najdete v tématu c-runtime-library/security-features-in-the-crt.

basic_string_view::crbegin

Vrátí hodnotu const_reverse_iterator , která řeší první prvek v obráceném basic_string_viewobjektu .

constexpr const_reverse_iterator crbegin() const noexcept;

Vrácená hodnota

A const_reverse_iterator , který řeší první prvek v obráceném basic_string_viewobjektu .

basic_string_view::crend

Stejné jako rend.

constexpr const_reverse_iterator crend() const noexcept;

Vrácená hodnota

const_reverse_iterator Vrátí adresu, která je za koncem obráceného basic_string_viewobjektu .

basic_string_view::data

Vrátí nezpracovaný nevlastní ukazatel na sekvenci znaků const objektu, který byl použit k vytvoření objektu basic_string_view.

constexpr value_type *data() const noexcept;

Vrácená hodnota

Ukazatel na const na první prvek sekvence znaků.

Poznámky

Ukazatel nemůže změnit znaky.

Posloupnost basic_string_view znaků není nutně ukončena hodnotou null. Návratový typ data není platný řetězec jazyka C, protože se nepřidá žádný znak null. Znak \0 null nemá žádný zvláštní význam v objektu typu basic_string_view a může být součástí objektu basic_string_view stejně jako jakýkoli jiný znak.

basic_string_view::empty

Testuje, zda basic_string_view obsahuje znaky, nebo ne.

constexpr bool empty() const noexcept;

Vrácená hodnota

true pokud objekt neobsahuje basic_string_view žádné znaky; false pokud má aspoň jeden znak.

Poznámky

Členová funkce je ekvivalentní size() == 0.

basic_string_view::end

Vrátí náhodný přístup const_iterator , který odkazuje na jeden po posledním prvku.

constexpr const_iterator end() const noexcept;

Vrácená hodnota

Vrátí náhodný přístup const_iterator , který odkazuje na jeden po posledním prvku.

Poznámky

end slouží k otestování, zda const_iterator dosáhla konce jeho basic_string_view. Hodnota vrácená end by neměla být dereferenced.

basic_string_view::ends_with

Zkontrolujte, jestli zobrazení řetězců končí zadanou příponou.

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;

Parametry

c
Přípona jednoho znaku, která se má vyhledat.

sv
Zobrazení řetězců obsahující příponu, která se má vyhledat.
Můžete předat std::basic_string, který převede na basic_string_view.

x
Řetězec znaků ukončený hodnotou null obsahující příponu, která se má vyhledat.

Vrácená hodnota

true pokud zobrazení řetězce končí zadanou příponou; false Jinak.

Poznámky

ends_with() je nový v jazyce C++20. Pokud ho chcete použít, zadejte možnost kompilátoru /std:c++20 nebo novější.

Podívejte starts_with se, jestli zobrazení řetězců začíná zadanou předponou.

Příklad

// 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

basic_string_view Vyhledá první výskyt znaku nebo podřetědce odpovídající zadané sekvenci znaků ve směru dopředu.

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;

Parametry

str
Členová basic_string_view funkce, pro kterou se má hledat.

chVal
Hodnota znaku, kterou má členská funkce vyhledat.

offset
Index, na kterém má hledání začínat.

ptr
Řetězec jazyka C, pro který má členová funkce vyhledávat.

count
Počet znaků v ptr, počítá se dopředu od prvního znaku.

Vrácená hodnota

Index prvního znaku nalezeného podřetězce, v opačném případě npos.

basic_string_view::find_first_not_of

Vyhledá první znak, který není prvkem zadaného basic_string_view nebo konvertibilního objektu řetězce.

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;

Parametry

str
Členová basic_string_view funkce, pro kterou se má hledat.

chVal
Hodnota znaku, kterou má členská funkce vyhledat.

offset
Index, na kterém má hledání začínat.

ptr
Řetězec jazyka C, pro který má členová funkce vyhledávat.

count
Počet znaků, počítání vpřed od prvního znaku v řetězci jazyka C, pro který se má členová funkce prohledávat.

Vrácená hodnota

Index prvního znaku nalezeného podřetězce, v opačném případě npos.

basic_string_view::find_first_of

Vyhledá první znak, který odpovídá libovolnému prvku zadaného basic_string_viewznaku .

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;

Parametry

chVal
Hodnota znaku, kterou má členská funkce vyhledat.

offset
Index, na kterém má hledání začínat.

ptr
Řetězec jazyka C, pro který má členová funkce vyhledávat.

count
Počet znaků, počítání vpřed od prvního znaku v řetězci jazyka C, pro který se má členová funkce prohledávat.

str
Členová basic_string_view funkce, pro kterou se má hledat.

Vrácená hodnota

Index prvního znaku nalezeného podřetězce, v opačném případě npos.

basic_string_view::find_last_not_of

Vyhledá poslední znak, který není žádným prvkem zadaného basic_string_viewznaku .

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;

Parametry

str
Členová basic_string_view funkce, pro kterou se má hledat.

chVal
Hodnota znaku, kterou má členská funkce vyhledat.

offset
Index, na kterém má být hledání dokončeno.

ptr
Řetězec jazyka C, pro který má členová funkce vyhledávat.

count
Počet znaků, počítání vpřed od prvního znaku, v ptr.

Vrácená hodnota

Index prvního znaku nalezeného podřetězce, v opačném případě string_view::npos.

basic_string_view::find_last_of

Vyhledá poslední znak, který odpovídá libovolnému prvku zadaného basic_string_viewznaku .

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;

Parametry

str
Členová basic_string_view funkce, pro kterou se má hledat.

chVal
Hodnota znaku, kterou má členská funkce vyhledat.

offset
Index, na kterém má být hledání dokončeno.

ptr
Řetězec jazyka C, pro který má členová funkce vyhledávat.

count
Počet znaků, počítání vpřed od prvního znaku v řetězci jazyka C, pro který se má členová funkce prohledávat.

Vrácená hodnota

Index posledního znaku podřetětědce, který byl při úspěchu vyhledána; jinak npos.

basic_string_view::front

Vrátí hodnotu const_reference k prvnímu prvku.

constexpr const_reference front() const;

Vrácená hodnota

A const_reference k prvnímu prvku.

Poznámky

Vyvolá výjimku, pokud basic_string_view je prázdná.

basic_string_view::length

Vrátí aktuální počet prvků.

constexpr size_type length() const noexcept;

Poznámky

Členová funkce je stejná jako size.

basic_string_view::max_size

Vrátí maximální počet znaků, které basic_string_view může obsahovat.

constexpr size_type max_size() const noexcept;

Vrácená hodnota

Maximální počet znaků, které basic_string_view může obsahovat.

Poznámky

Výjimka typu length_error je vyvolán, když operace vytvoří s délkou basic_string_view větší než max_size().

basic_string_view::operator=

basic_string_view Přiřadí objekt řetězce nebo sklápěcí objekt jinému basic_string_view.

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

Příklad

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

basic_string_view::operator[]

const_reference Poskytuje znak se zadaným indexem.

constexpr const_reference operator[](size_type offset) const;

Parametry

offset
Index prvku, na který se má odkazovat.

Vrácená hodnota

Znak na const_reference pozici určené indexem parametru.

Poznámky

První prvek má index nuly a následující prvky jsou indexovány po sobě kladnými celými čísly, takže basic_string_view délka má *n*th prvek indexovaný číslem n-1n .

operator[] je rychlejší než členová funkce at pro poskytování přístupu pro čtení k prvkům objektu basic_string_view.

operator[] nekontroluje, jestli je index předaný jako argument platný. Neplatný index předaný výsledkům operator[] nedefinovaného chování.

Vrácený odkaz může být neplatný, pokud jsou podkladová řetězcová data upravena nebo odstraněna vlastníkem objektu.

Při kompilaci s nastavenou _ITERATOR_DEBUG_LEVEL na hodnotu 1 nebo 2 dojde k chybě za běhu, pokud se pokusíte získat přístup k prvku mimo hranice basic_string_view. Další informace naleznete v tématu Kontrola iterátorů.

basic_string_view::rbegin

const Vrátí iterátor na první prvek v obráceném směru basic_string_view.

constexpr const_reverse_iterator rbegin() const noexcept;

Vrácená hodnota

Vrátí iterátor náhodného přístupu k prvnímu prvku v obráceném basic_string_viewobjektu , adresování toho, co by bylo posledním prvkem v odpovídající nereverzní .basic_string_view

Poznámky

rbegin se používá s obráceným opakem basic_string_view , stejně jako begin se používá s basic_string_view. rbegin lze použít k inicializaci iterace zpět.

basic_string_view::remove_prefix

Přesune ukazatel dopředu o zadaný počet prvků.

constexpr void remove_prefix(size_type n);

Poznámky

Podkladová data zůstanou beze změny. Přesune basic_string_view ukazatel dopředu podle n prvků a nastaví soukromý size datový člen na size - n.

basic_string_view::remove_suffix

Zmenšuje velikost zobrazení podle zadaného počtu prvků, které začínají od pozadí.

constexpr void remove_suffix(size_type n);

Poznámky

Ponechá podkladová data a ukazatel na něj beze změny. Nastaví soukromý size datový člen na size - n.

basic_string_view::rend

const Vrátí iterátor, který odkazuje na poslední prvek v obráceném směru basic_string_view.

constexpr reverse_iterator rend() const noexcept;

Vrácená hodnota

Reverzní const iterátor náhodného přístupu, který odkazuje na poslední prvek v obráceném směru basic_string_view.

Poznámky

rend se používá s obráceným opakem basic_string_view , stejně jako end se používá s basic_string_view. rend lze použít k otestování, zda reverzní iterátor dosáhl konce jeho basic_string_view. Hodnota vrácená rend by neměla být dereferenced.

basic_string_view::rfind

Vyhledá v obráceném basic_string_view směru podřetěděcí řetězec, který odpovídá zadané sekvenci znaků.

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;

Parametry

chVal
Hodnota znaku, kterou má členská funkce vyhledat.

offset
Index, na kterém má hledání začínat.

ptr
Řetězec jazyka C, pro který má členová funkce vyhledávat.

count
Počet znaků, počítání vpřed od prvního znaku v řetězci jazyka C, pro který se má členová funkce prohledávat.

str
Členová basic_string_view funkce, pro kterou se má hledat.

Vrácená hodnota

Index prvního znaku podřetětědce při úspěchu; jinak npos.

basic_string_view::size

Vrátí počet prvků v sadě basic_string_view.

constexpr size_type size() const noexcept;

Vrácená hodnota

Délka basic_string_view.

Poznámky

A basic_string_view může změnit jeho délku, například o remove_prefix a remove_suffix. Vzhledem k tomu, že se tím nezmění podkladová řetězcová data, není velikost basic_string_view podkladových dat nutně velikostí podkladových dat.

basic_string_view::starts_with

Zkontrolujte, jestli zobrazení řetězců začíná zadanou předponou.

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;

Parametry

c
Předpona jednoho znaku, která se má vyhledat.

sv
Zobrazení řetězců obsahující předponu, která se má vyhledat.
Můžete předat std::basic_string, který převede na zobrazení řetězce.

x
Řetězec znaků ukončený hodnotou null obsahující předponu, která se má vyhledat.

Vrácená hodnota

true pokud řetězec začíná zadanou předponou; false Jinak.

Poznámky

starts_with() je nový v jazyce C++20. Pokud ho chcete použít, zadejte možnost kompilátoru std:c++20 nebo novější.

Podívejte ends_with se, jestli řetězec končí příponou.

Příklad

// 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

Vrátí hodnotu basic_string_view , která představuje (maximálně) zadaný počet znaků ze zadané pozice.

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

Parametry

offset
Index, který nachází prvek na pozici, ze které se kopie vytvoří, s výchozí hodnotou 0.

count
Počet znaků, které se mají zahrnout do podřetězence, pokud jsou přítomné.

Vrácená hodnota

Objekt basic_string_view , který představuje zadanou dílčí sekvenci prvků.

basic_string_view::swap

Vymění dvě basic_string_viewhodnoty, jinými slovy ukazatele na podkladová řetězcová data a hodnoty velikosti.

constexpr void swap(basic_string_view& sv) noexcept;

Parametry

sv
Zdroj basic_string_view , jehož hodnoty ukazatele a velikosti mají být vyměněné s cílem basic_string_view.

Viz také

<string_view>
Bezpečný přístup z více vláken ve standardní knihovně C++