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 typuchar
wstring_view
prowchar_t
u16string_view
prochar16_t
u32string_view
prochar32_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_view s 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_view basic_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_with C++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_with C++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 - 1
n
. 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_view
v 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ší nebostrv
ptr
- Nula, pokud jsou dvě sekvence znaků stejné
- Kladná hodnota, pokud je tato
basic_string_view
hodnota větší nebostrv
ptr
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_view
objektu .
constexpr const_reverse_iterator crbegin() const noexcept;
Vrácená hodnota
A const_reverse_iterator
, který řeší první prvek v obráceném basic_string_view
objektu .
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_view
objektu .
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_view
znaku .
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_view
znaku .
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_view
znaku .
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-1
n
.
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_view
objektu , 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_view
hodnoty, 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++