Klasa `basic_string_view`

Artykuł
10/12/2023

Szablon basic_string_view<charT> klasy został dodany w języku C++17, aby służyć jako bezpieczny i wydajny sposób akceptowania różnych niepowiązanych typów ciągów bez konieczności tworzenia szablonów funkcji na tych typach. Klasa przechowuje wskaźnik nienależący do ciągłej sekwencji danych znaków i długość określającą liczbę znaków w sekwencji. Nie podjęto żadnych założeń dotyczących tego, czy sekwencja jest zakończona o wartości null.

Biblioteka standardowa definiuje kilka specjalizacji na podstawie typu elementów:

string_view
wstring_view
u16string_view
u32string_view

Opisano basic_string_view minimalny wspólny interfejs niezbędny do odczytywania danych ciągu. Zapewnia on const dostępu do danych bazowych; nie tworzy żadnych kopii (z wyjątkiem copy funkcji). Dane mogą lub nie mogą zawierać wartości null (\0) w dowolnej pozycji. Obiekt basic_string_view nie ma kontroli nad okresem istnienia obiektu. Jest to odpowiedzialność obiektu wywołującego za upewnienie się, że podstawowe dane ciągu są prawidłowe.

Funkcja, która akceptuje parametr typu string_view , może być wykonywana w celu pracy z dowolnym typem przypominającym ciąg, bez tworzenia funkcji w szablonie lub ograniczania funkcji do określonego podzestawu typów ciągów. Jedynym wymaganiem jest to, że niejawna konwersja istnieje z typu ciągu na string_view. Wszystkie standardowe typy ciągów są niejawnie konwertowane na element string_view , który zawiera ten sam typ elementu. Innymi słowy, element jest std::string konwertowany na element , string_view ale nie do wstring_view.

W poniższym przykładzie przedstawiono funkcję f inną niż szablon, która przyjmuje parametr typu wstring_view. Można go wywołać za pomocą argumentów typu std::wstring, wchar_t*i 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);

Składnia

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

Parametry

CharType
Typ znaków przechowywanych w obiekcie basic_string_view. Biblioteka Standardowa języka C++ udostępnia następujące definicje typów dla specjalizacji tego szablonu.

string_view dla elementów typu char
wstring_viewFor wchar_t
u16string_view dla char16_t
u32string_view dla char32_t.

Traits
Wartość domyślna to char_traitsCharType<>.

Konstruktory

Konstruktor	opis
`basic_string_view`	Tworzy obiekt, który `basic_string_view` jest pusty lub inny wskazuje wszystkie lub część danych innego obiektu ciągu albo tablicę znaków w stylu C.

Typedefs

Nazwa typu	opis
`const_iterator`	Iterator dostępu losowego, który może odczytywać `const` elementy.
`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;`

Operatory składowe

Operator	opis
`operator=`	`basic_string_view` Przypisuje obiekt ciągu lub kabriolet do innego `basic_string_view`obiektu .
`operator[]`	Zwraca element w określonym indeksie.

Funkcje składowe

Funkcja składowa	opis
`at`	Zwraca element `const_reference` do elementu w określonej lokalizacji.
`back`	Zwraca element `const_reference` do ostatniego elementu.
`begin`	`const` Zwraca iterator odnoszący się do pierwszego elementu. (`basic_string_view`s są niezmienne).
`cbegin`	Tak samo jak `begin`.
`cend`	`const` Zwraca iterator wskazujący jeden obok ostatniego elementu.
`copy`	Kopiuje najwyżej określoną liczbę znaków z indeksowanej pozycji w źródle `basic_string_view` do docelowej tablicy znaków. (Niezalecane. Zamiast tego użyj polecenia `_Copy_s` .
`_Copy_s`	Funkcja bezpiecznego kopiowania CRT.
`compare`	Porównuje element `basic_string_view` z określoną `basic_string_view` wartością, aby określić, czy są one równe, czy też leksykograficznie mniejsze niż druga.
`crbegin`	Tak samo jak `rbegin`.
`crend`	Tak samo jak `rend`.
`data`	Zwraca nieprzetworzone wskaźnik nienależące do sekwencji znaków.
`empty`	Sprawdza, czy zawiera `basic_string_view` znaki.
`end`	Tak samo jak `cend`.
`ends_with`^C++20	Sprawdź, czy widok ciągu kończy się określonym sufiksem.
`find`	Wyszukuje w kierunku do przodu pierwsze wystąpienie podciągów, które pasuje do określonej sekwencji znaków.
`find_first_not_of`	Wyszukuje pierwszy znak, który nie jest żadnym elementem określonego `basic_string_view` lub konwertowanego obiektu ciągu.
`find_first_of`	Wyszukuje pierwszy znak, który pasuje do dowolnego elementu określonego `basic_string_view` lub konwertowanego obiektu ciągu.
`find_last_not_of`	Wyszukuje ostatni znak, który nie jest żadnym elementem określonego `basic_string_view` lub konwertowanego obiektu ciągu.
`find_last_of`	Wyszukuje ostatni znak, który jest elementem określonego `basic_string_view` lub konwertowanego obiektu ciągu.
`front`	Zwraca element `const_reference` do pierwszego elementu.
`length`	Zwraca bieżącą liczbę elementów.
`max_size`	Zwraca maksymalną liczbę znaków, które `basic_string_view` może zawierać.
`rbegin`	`const` Zwraca iterator, który adresuje pierwszy element w odwróconym elemecie `basic_string_view`.
`remove_prefix`	Przenosi wskaźnik do przodu przez określoną liczbę elementów.
`remove_suffix`	Zmniejsza rozmiar widoku o określoną liczbę elementów rozpoczynających się od tyłu.
`rend`	`const` Zwraca iterator wskazujący jeden obok ostatniego elementu w odwróconym elemecie `basic_string_view`.
`rfind`	Wyszukuje odwrotnie `basic_string_view` w przypadku pierwszego wystąpienia podciągów pasujących do określonej sekwencji znaków.
`size`	Zwraca bieżącą liczbę elementów.
`starts_with`^C++20	Sprawdź, czy widok ciągu rozpoczyna się od danego prefiksu.
`substr`	Zwraca podciąg o określonej długości rozpoczynający się od określonego indeksu.
`swap`	Wymiana zawartości dwóch `basic_string_view` obiektów.

Uwagi

Jeśli funkcja zostanie poproszona o wygenerowanie sekwencji dłuższej niż max_size elementy, funkcja zgłasza błąd długości, zgłaszając obiekt typu length_error.

Wymagania

std:c++17 lub nowszy.

Nagłówka:<string_view>

Obszaru nazw:std

`basic_string_view::at`

const_reference Zwraca znak do znaku w określonym indeksie opartym na zera.

constexpr const_reference at(size_type offset) const;

Parametry

offset
Indeks elementu do przywołowania.

Wartość zwracana

Znak const_reference do znaku w pozycji określonej przez indeks parametrów.

Uwagi

Pierwszy element ma indeks zero, a następujące elementy są indeksowane kolejno przez dodatnie liczby całkowite, dzięki czemu basic_string_view długość n ma element **nth indeksowany przez liczbę n - 1. at zgłasza wyjątek dla nieprawidłowych indeksów, w przeciwieństwie do operator[].

Ogólnie rzecz biorąc, zalecamy, aby at w przypadku sekwencji takich jak std::vector i basic_string_view nigdy nie należy ich używać. Nieprawidłowy indeks przekazany do sekwencji to błąd logiki, który należy odnaleźć i naprawić podczas programowania. Jeśli program nie jest pewien, że jego indeksy są prawidłowe, należy je przetestować, a nie wywołać at() i polegać na wyjątkach, aby bronić przed nieostrożnym programowaniem.

W celu uzyskania więcej informacji, zobacz następujący temat: basic_string_view::operator[].

Przykład

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

Zwraca element const_reference do ostatniego elementu.

constexpr const_reference back() const;

Wartość zwracana

Od ostatniego const_reference elementu w elemecie basic_string_view.

Uwagi

Zgłasza wyjątek, jeśli basic_string_view element jest pusty.

Należy pamiętać, że po zmodyfikowaniu elementu basic_string_view , na przykład przez wywołanie remove_suffixmetody , element zwracany przez tę funkcję nie jest już ostatnim elementem w danych bazowych.

Przykład

Element string_view skonstruowany z literałem ciągu języka C nie zawiera wartości null zakończenia. Dlatego w poniższym przykładzie back zwraca wartość 'p' , a nie '\0'.

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

Osadzone wartości null są traktowane jako każdy inny znak:

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

`basic_string_view::basic_string_view`

Tworzy element 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
Wskaźnik do wartości znaków.

len
Liczba znaków do uwzględnienia w widoku.

Uwagi

Konstruktory z parametrem charT* zakładają, że dane wejściowe są zakończone wartością null, ale wartość null zakończenia nie jest uwzględniona w obiekcie basic_string_view.

Można również utworzyć obiekt basic_string_view z literałem. Zobacz: operator"" sv.

`basic_string_view::begin`

Tak samo jak cbegin.

constexpr const_iterator begin() const noexcept;

Wartość zwracana

const_iterator Zwraca adresowanie pierwszego elementu.

`basic_string_view::cbegin`

Zwraca element const_iterator , który adresuje pierwszy element w zakresie.

constexpr const_iterator cbegin() const noexcept;

Wartość zwracana

const Iterator dostępu losowego, który wskazuje pierwszy element zakresu lub lokalizację tuż poza końcem pustego zakresu (dla pustego zakresu, cbegin() == cend()).

`basic_string_view::cend`

Zwraca obiekt const_iterator , który adresuje lokalizację tuż poza ostatnim elementem w zakresie.

constexpr const_iterator cend() const noexcept;

Wartość zwracana

const Iterator dostępu losowego, który wskazuje tuż poza końcem zakresu.

Uwagi

Wartość zwracana przez cend nie powinna być wyłuszczone.

`basic_string_view::compare`

Czy porównanie uwzględniające wielkość liter z określonym basic_string_view (lub typem ciągów konwertowanych) określa, czy dwa obiekty są równe, lub jeśli jeden jest leksykograficznie mniejszy niż drugi. Operatory <string_view> używają tej funkcji składowej do porównywania.

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
Wartość , która ma być porównywana basic_string_view z tym basic_string_viewelementem .

pos
Indeks tego basic_string_view , na którym rozpoczyna się porównanie.

num
Maksymalna liczba znaków z tej basic_string_view wartości do porównania.

num2
Maksymalna liczba znaków z strv do porównania.

offset
Indeks, w strv którym rozpoczyna się porównanie.

ptr
Ciąg języka C do porównania z tym basic_string_viewciągiem .

Wartość zwracana

Wartość ujemna, jeśli jest basic_string_view mniejsza niż strv lub ptr
Zero, jeśli dwie sekwencje znaków są równe
Wartość dodatnia, jeśli basic_string_view jest większa niż strv lub ptr

Uwagi

Funkcje compare składowe wykonują porównanie wielkości liter dla wszystkich lub części każdej sekwencji znaków.

Przykład

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

Kopiuje najwyżej określoną liczbę znaków z indeksowanej pozycji w źródle basic_string_view do docelowej tablicy znaków. Zalecamy zamiast tego użycie funkcji basic_string_view::_Copy_s secure.

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

Parametry

ptr
Docelowa tablica znaków, do której mają zostać skopiowane elementy.

count
Liczba znaków, które mają zostać skopiowane, co najwyżej ze źródła basic_string_view.

offset
Pozycja początkowa w źródle basic_string_view , z którego mają zostać wykonane kopie.

Wartość zwracana

Liczba skopiowanych znaków.

Uwagi

Znak null nie jest dołączany na końcu kopii.

`basic_string_view::_Copy_s`

Secure CRT copy function to be used zamiast copy.

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

Parametry

dest
Docelowa tablica znaków, do której mają zostać skopiowane elementy.

dest_size
Rozmiar dest.

count Liczba znaków, które mają zostać skopiowane, co najwyżej z ciągu źródłowego.

_Off
Pozycja początkowa w ciągu źródłowym, z którego mają zostać wykonane kopie.

Wartość zwracana

Liczba skopiowanych znaków.

Uwagi

Znak null nie jest dołączany na końcu kopii.

Aby uzyskać więcej informacji, zobacz c-runtime-library/security-features-in-the-crt.

`basic_string_view::crbegin`

Zwraca element const_reverse_iterator , który adresuje pierwszy element w odwróconym basic_string_viewobiekcie .

constexpr const_reverse_iterator crbegin() const noexcept;

Wartość zwracana

Element const_reverse_iterator , który adresuje pierwszy element w odwróconym basic_string_viewobiekcie .

`basic_string_view::crend`

Tak samo jak rend.

constexpr const_reverse_iterator crend() const noexcept;

Wartość zwracana

Zwraca element, który const_reverse_iterator adresuje jeden obok końca odwróconego basic_string_viewobiektu .

`basic_string_view::data`

Zwraca nieprzetworzone wskaźnik nienależący do sekwencji znaków const obiektu, który został użyty do skonstruowania basic_string_viewobiektu .

constexpr value_type *data() const noexcept;

Wartość zwracana

Wskaźnik do const do pierwszego elementu sekwencji znaków.

Uwagi

Wskaźnik nie może modyfikować znaków.

Sekwencja basic_string_view znaków nie musi być zakończona wartością null. Zwracany typ elementu data nie jest prawidłowym ciągiem języka C, ponieważ nie jest dołączany żaden znak null. Znak \0 null nie ma specjalnego znaczenia w obiekcie typu basic_string_view i może być częścią basic_string_view obiektu tak samo jak każdy inny znak.

`basic_string_view::empty`

Sprawdza, czy zawiera basic_string_view znaki, czy nie.

constexpr bool empty() const noexcept;

Wartość zwracana

truebasic_string_view jeśli obiekt nie zawiera żadnych znaków; false jeśli ma co najmniej jeden znak.

Uwagi

Funkcja składowa jest równoważna size() == 0.

`basic_string_view::end`

Zwraca losowy dostęp const_iterator wskazujący jeden obok ostatniego elementu.

constexpr const_iterator end() const noexcept;

Wartość zwracana

Zwraca losowy dostęp const_iterator wskazujący jeden obok ostatniego elementu.

Uwagi

end służy do testowania, czy element const_iterator osiągnął koniec jego basic_string_viewelementu . Wartość zwracana przez end nie powinna być wyłuszczone.

`basic_string_view::ends_with`

Sprawdź, czy widok ciągu kończy się określonym sufiksem.

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
Sufiks pojedynczego znaku do wyszukania.

sv
Widok ciągu zawierający sufiks do wyszukania.
Można przekazać element std::basic_string, który konwertuje na element basic_string_view.

x
Ciąg znaków o wartości null zawierający sufiks do wyszukania.

Wartość zwracana

true jeśli widok ciągu kończy się określonym sufiksem; false Inaczej.

Uwagi

ends_with() jest nowy w języku C++20. Aby go użyć, określ lub nowszą /std:c++20 opcję kompilatora.

Zobacz starts_with , aby sprawdzić, czy widok ciągu rozpoczyna się od określonego prefiksu.

Przykład

// 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 Wyszukuje w kierunku do przodu pierwsze wystąpienie znaku lub podciąg, który pasuje do określonej sekwencji znaków.

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
Element basic_string_view , dla którego ma być wyszukiwana funkcja składowa.

chVal
Wartość znaku, dla której ma być wyszukiwana funkcja składowa.

offset
Indeks, na którym ma rozpocząć się wyszukiwanie.

ptr
Ciąg języka C, dla którego ma być wyszukiwana funkcja składowa.

count
Liczba znaków w elemecie ptr, zliczając do przodu od pierwszego znaku.

Wartość zwracana

Indeks pierwszego znaku podciągów wyszukiwany po pomyślnym zakończeniu; w przeciwnym razie npos.

`basic_string_view::find_first_not_of`

Wyszukuje pierwszy znak, który nie jest elementem określonego basic_string_view lub konwertowanego obiektu ciągu.

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
Element basic_string_view , dla którego ma być wyszukiwana funkcja składowa.

chVal
Wartość znaku, dla której ma być wyszukiwana funkcja składowa.

offset
Indeks, na którym ma rozpocząć się wyszukiwanie.

ptr
Ciąg języka C, dla którego ma być wyszukiwana funkcja składowa.

count
Liczba znaków, zliczając do przodu od pierwszego znaku, w ciągu języka C, dla którego ma być wyszukiwana funkcja składowa.

Wartość zwracana

Indeks pierwszego znaku podciągów wyszukiwany po pomyślnym zakończeniu; w przeciwnym razie npos.

`basic_string_view::find_first_of`

Wyszukuje pierwszy znak, który pasuje do dowolnego elementu określonego basic_string_viewelementu .

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
Wartość znaku, dla której ma być wyszukiwana funkcja składowa.

offset
Indeks, na którym ma rozpocząć się wyszukiwanie.

ptr
Ciąg języka C, dla którego ma być wyszukiwana funkcja składowa.

count
Liczba znaków, zliczając do przodu od pierwszego znaku, w ciągu języka C, dla którego ma być wyszukiwana funkcja składowa.

str
Element basic_string_view , dla którego ma być wyszukiwana funkcja składowa.

Wartość zwracana

Indeks pierwszego znaku podciągów wyszukiwany po pomyślnym zakończeniu; w przeciwnym razie npos.

`basic_string_view::find_last_not_of`

Wyszukuje ostatni znak, który nie jest żadnym elementem określonego basic_string_viewelementu .

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
Element basic_string_view , dla którego ma być wyszukiwana funkcja składowa.

chVal
Wartość znaku, dla której ma być wyszukiwana funkcja składowa.

offset
Indeks, w którym wyszukiwanie ma zakończyć się.

ptr
Ciąg języka C, dla którego ma być wyszukiwana funkcja składowa.

count
Liczba znaków, zliczanie do przodu z pierwszego znaku w pliku ptr.

Wartość zwracana

Indeks pierwszego znaku podciągów wyszukiwany po pomyślnym zakończeniu; w przeciwnym razie string_view::npos.

`basic_string_view::find_last_of`

Wyszukuje ostatni znak, który pasuje do dowolnego elementu określonego basic_string_viewelementu .

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
Element basic_string_view , dla którego ma być wyszukiwana funkcja składowa.

chVal
Wartość znaku, dla której ma być wyszukiwana funkcja składowa.

offset
Indeks, w którym wyszukiwanie ma zakończyć się.

ptr
Ciąg języka C, dla którego ma być wyszukiwana funkcja składowa.

count
Liczba znaków, zliczając do przodu od pierwszego znaku, w ciągu języka C, dla którego ma być wyszukiwana funkcja składowa.

Wartość zwracana

Indeks ostatniego znaku podciągów wyszukiwany po pomyślnym zakończeniu; w przeciwnym razie npos.

`basic_string_view::front`

Zwraca element const_reference do pierwszego elementu.

constexpr const_reference front() const;

Wartość zwracana

Od A const_reference do pierwszego elementu.

Uwagi

Zgłasza wyjątek, jeśli basic_string_view element jest pusty.

`basic_string_view::length`

Zwraca bieżącą liczbę elementów.

constexpr size_type length() const noexcept;

Uwagi

Funkcja składowa jest taka sama jak size.

`basic_string_view::max_size`

Zwraca maksymalną liczbę znaków, które basic_string_view może zawierać.

constexpr size_type max_size() const noexcept;

Wartość zwracana

Maksymalna liczba znaków, które basic_string_view może zawierać.

Uwagi

Wyjątek typu length_error jest zgłaszany, gdy operacja generuje obiekt basic_string_view o długości większej niż max_size().

`basic_string_view::operator=`

basic_string_view Przypisuje obiekt ciągu lub kabriolet do innego basic_string_viewobiektu .

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

Przykład

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

`basic_string_view::operator[]`

const_reference Udostępnia znak z określonym indeksem.

constexpr const_reference operator[](size_type offset) const;

Parametry

offset
Indeks elementu do przywołowania.

Wartość zwracana

Znak const_reference do znaku w pozycji określonej przez indeks parametrów.

Uwagi

Pierwszy element ma indeks zero, a następujące elementy są indeksowane kolejno przez dodatnie liczby całkowite, dzięki czemu długość basic_string_viewn ma element **nth indeksowany przez liczbę n-1.

operator[] funkcja jest szybsza niż funkcja at składowa w celu zapewnienia dostępu do odczytu do elementów elementu basic_string_view.

operator[] Nie sprawdza, czy indeks przekazany jako argument jest prawidłowy. Nieprawidłowy indeks przekazany do operator[] powoduje niezdefiniowane zachowanie.

Zwrócone odwołanie może zostać unieważnione, jeśli bazowe dane ciągu zostaną zmodyfikowane lub usunięte przez obiekt będący właścicielem.

Podczas kompilowania z _ITERATOR_DEBUG_LEVEL ustawionym na 1 lub 2 wystąpi błąd czasu wykonywania, jeśli spróbujesz uzyskać dostęp do elementu poza granicami basic_string_view. Aby uzyskać więcej informacji, zobacz Sprawdzono iteratory.

`basic_string_view::rbegin`

const Zwraca iterator do pierwszego elementu w odwróconym basic_string_viewobiekcie .

constexpr const_reverse_iterator rbegin() const noexcept;

Wartość zwracana

Zwraca iterator dostępu losowego do pierwszego elementu w odwróconym basic_string_viewelemecie , zwracając się do tego, co byłoby ostatnim elementem w odpowiadającym niereversed .basic_string_view

Uwagi

rbegin jest używany z odwróconym basic_string_view elementem, tak jak begin jest używany z elementem basic_string_view. rbegin można użyć do zainicjowania iteracji do tyłu.

`basic_string_view::remove_prefix`

Przenosi wskaźnik do przodu przez określoną liczbę elementów.

constexpr void remove_prefix(size_type n);

Uwagi

Pozostawia dane bazowe bez zmian. basic_string_view Przenosi wskaźnik do przodu według n elementów i ustawia element członkowski danych prywatnych size na size - n.

`basic_string_view::remove_suffix`

Zmniejsza rozmiar widoku o określoną liczbę elementów rozpoczynających się od tyłu.

constexpr void remove_suffix(size_type n);

Uwagi

Pozostawia dane bazowe i wskaźnik do niego bez zmian. Ustawia element członkowski danych prywatnych size na size - n.

`basic_string_view::rend`

const Zwraca iterator wskazujący jeden obok ostatniego elementu w odwróconym elemecie basic_string_view.

constexpr reverse_iterator rend() const noexcept;

Wartość zwracana

Odwrotny const iterator dostępu losowego wskazujący jeden obok ostatniego elementu w odwróconym elemecie basic_string_view.

Uwagi

rend jest używany z odwróconym basic_string_view elementem, tak jak end jest używany z elementem basic_string_view. rend można użyć do sprawdzenia, czy iterator odwrotny osiągnął koniec jego basic_string_view. Wartość zwracana przez rend nie powinna być wyłuszczone.

`basic_string_view::rfind`

Wyszukuje odwrotnie basic_string_view podciąg zgodny z określoną sekwencją znaków.

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
Wartość znaku, dla której ma być wyszukiwana funkcja składowa.

offset
Indeks, na którym ma rozpocząć się wyszukiwanie.

ptr
Ciąg języka C, dla którego ma być wyszukiwana funkcja składowa.

count
Liczba znaków, zliczając do przodu od pierwszego znaku, w ciągu języka C, dla którego ma być wyszukiwana funkcja składowa.

str
Element basic_string_view , dla którego ma być wyszukiwana funkcja składowa.

Wartość zwracana

Indeks pierwszego znaku podciągów po pomyślnym zakończeniu; w przeciwnym razie npos.

`basic_string_view::size`

Zwraca liczbę elementów w elem.basic_string_view

constexpr size_type size() const noexcept;

Wartość zwracana

Długość obiektu basic_string_view.

Uwagi

Element basic_string_view może modyfikować jego długość, na przykład przez remove_prefix i remove_suffix. Ponieważ nie modyfikuje to danych ciągów bazowych, rozmiar elementu basic_string_view nie musi być rozmiarem danych bazowych.

`basic_string_view::starts_with`

Sprawdź, czy widok ciągu rozpoczyna się od określonego prefiksu.

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
Prefiks pojedynczego znaku do wyszukania.

sv
Widok ciągu zawierający prefiks do wyszukania.
Można przekazać element std::basic_string, który konwertuje na widok ciągu.

x
Ciąg znaków o wartości null zawierający prefiks do wyszukania.

Wartość zwracana

true jeśli ciąg rozpoczyna się od określonego prefiksu; false Inaczej.

Uwagi

starts_with() jest nowy w języku C++20. Aby go użyć, określ lub nowszą std:c++20 opcję kompilatora.

Zobacz ends_with , czy ciąg kończy się sufiksem.

Przykład

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

Zwraca wartość reprezentującą basic_string_view (co najwyżej) określoną liczbę znaków z określonej pozycji.

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

Parametry

offset
Indeks lokalizujący element na pozycji, z której jest wykonana kopia, z wartością domyślną 0.

count
Liczba znaków do uwzględnienia w podciągnie, jeśli są obecne.

Wartość zwracana

basic_string_view Obiekt reprezentujący określoną podsekwencję elementów.

`basic_string_view::swap`

Wymienia dwa basic_string_views, czyli wskaźniki do danych ciągów bazowych i wartości rozmiaru.

constexpr void swap(basic_string_view& sv) noexcept;

Parametry

sv
Źródło basic_string_view , którego wskaźniki i wartości rozmiaru mają być wymieniane z wartością docelową basic_string_view.

Zobacz też

<string_view>
Bezpieczeństwo wątku w standardowej bibliotece C++

Share via

Klasa basic_string_view

Składnia

Parametry

Konstruktory

Typedefs

Operatory składowe

Funkcje składowe

Uwagi

Wymagania

basic_string_view::at

Parametry

Wartość zwracana

Uwagi

Przykład

basic_string_view::back

Wartość zwracana

Uwagi

Przykład

basic_string_view::basic_string_view

Parametry

Uwagi

basic_string_view::begin

Wartość zwracana

basic_string_view::cbegin

Wartość zwracana

basic_string_view::cend

Wartość zwracana

Uwagi

basic_string_view::compare

Parametry

Wartość zwracana

Uwagi

Przykład

basic_string_view::copy

Parametry

Wartość zwracana

Uwagi

basic_string_view::_Copy_s

Parametry

Wartość zwracana

Uwagi

basic_string_view::crbegin

Wartość zwracana

basic_string_view::crend

Wartość zwracana

basic_string_view::data

Wartość zwracana

Uwagi

basic_string_view::empty

Wartość zwracana

Uwagi

basic_string_view::end

Wartość zwracana

Uwagi

basic_string_view::ends_with

Parametry

Wartość zwracana

Uwagi

Przykład

basic_string_view::find

Parametry

Wartość zwracana

basic_string_view::find_first_not_of

Parametry

Wartość zwracana

basic_string_view::find_first_of

Parametry

Wartość zwracana

basic_string_view::find_last_not_of

Parametry

Wartość zwracana

basic_string_view::find_last_of

Parametry

Wartość zwracana

basic_string_view::front

Wartość zwracana

Uwagi

basic_string_view::length

Uwagi

Klasa `basic_string_view`

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