Classe `basic_string_view`

Articolo
10/12/2023

Il modello basic_string_view<charT> di classe è stato aggiunto in C++17 per fungere da modo sicuro ed efficiente per una funzione di accettare vari tipi di stringa non correlati senza che la funzione sia stata templatizzata su tali tipi. La classe contiene un puntatore non proprietario a una sequenza contigua di dati di tipo carattere e una lunghezza che specifica il numero di caratteri nella sequenza. Non viene fatto alcun presupposto sul fatto che la sequenza sia con terminazione Null.

La libreria standard definisce diverse specializzazioni in base al tipo degli elementi:

string_view
wstring_view
u16string_view
u32string_view

Un basic_string_view oggetto descrive l'interfaccia comune minima necessaria per leggere i dati stringa. Fornisce l'accesso const ai dati sottostanti; non esegue copie (ad eccezione della copy funzione). I dati possono contenere o meno valori Null (\0) in qualsiasi posizione. Un basic_string_view oggetto non ha alcun controllo sulla durata dell'oggetto. È responsabilità del chiamante assicurarsi che i dati della stringa sottostante siano validi.

Una funzione che accetta un parametro di tipo string_view può essere eseguita per funzionare con qualsiasi tipo di stringa, senza rendere la funzione in un modello o vincolare la funzione a un determinato subset di tipi stringa. L'unico requisito è che esiste una conversione implicita dal tipo stringa a string_view. Tutti i tipi di stringa standard sono convertibili in modo implicito in un string_view oggetto che contiene lo stesso tipo di elemento. In altre parole, un oggetto std::string è convertibile in un oggetto string_view ma non in un oggetto wstring_view.

Nell'esempio seguente viene illustrata una funzione f non modello che accetta un parametro di tipo wstring_view. Può essere chiamato con argomenti di tipo std::wstring, wchar_t*e 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);

Sintassi

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

Parametri

CharType
Tipo dei caratteri archiviati in basic_string_view. La libreria standard C++ fornisce i typedef seguenti per le specializzazioni di questo modello.

string_view per gli elementi di tipo char
wstring_viewPer wchar_t
u16string_view per char16_t
u32string_view per char32_t.

Traits
Il valore predefinito è char_traits<CharType>.

Costruttori

Costruttore	Descrizione
`basic_string_view`	Costruisce un oggetto `basic_string_view` vuoto o che punta a tutti o a una parte dei dati di un altro oggetto stringa o a una matrice di caratteri in stile C.

Typedef

Nome tipo	Descrizione
`const_iterator`	Iteratore ad accesso casuale in grado di leggere `const` gli elementi.
`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;`

Operatori membro

Operatore	Descrizione
`operator=`	Assegna un `basic_string_view` oggetto stringa convertibile o a un altro `basic_string_view`oggetto .
`operator[]`	Restituisce l'elemento in corrispondenza dell'indice specificato.

Funzioni membro

Funzione membro	Descrizione
`at`	Restituisce un `const_reference` oggetto all'elemento in una posizione specificata.
`back`	Restituisce un `const_reference` oggetto all'ultimo elemento.
`begin`	Restituisce un `const` iteratore che punta al primo elemento. (`basic_string_view`s sono non modificabili.
`cbegin`	Uguale a `begin`.
`cend`	Restituisce un `const` iteratore che punta a un altro oltre l'ultimo elemento.
`copy`	Copia al massimo un numero specificato di caratteri da una posizione indicizzata in un'origine `basic_string_view` a una matrice di caratteri di destinazione. (Non consigliato. Usare `_Copy_s` invece.
`_Copy_s`	Funzione di copia CRT sicura.
`compare`	Confronta un `basic_string_view` oggetto con un oggetto specificato `basic_string_view` per determinare se sono uguali o se uno è lessicograficamente minore dell'altro.
`crbegin`	Uguale a `rbegin`.
`crend`	Uguale a `rend`.
`data`	Restituisce un puntatore non proprietario non elaborato alla sequenza di caratteri.
`empty`	Verifica se l'oggetto `basic_string_view` contiene caratteri.
`end`	Uguale a `cend`.
`ends_with`^C++20	Controllare se una visualizzazione stringa termina con un suffisso specificato.
`find`	Cerca in avanti la prima occorrenza di una sottostringa che corrisponde a una sequenza di caratteri specificata.
`find_first_not_of`	Cerca il primo carattere che non è alcun elemento di un oggetto stringa specificato `basic_string_view` o convertibile.
`find_first_of`	Cerca il primo carattere che corrisponde a qualsiasi elemento di un oggetto stringa specificato `basic_string_view` o convertibile.
`find_last_not_of`	Cerca l'ultimo carattere che non è alcun elemento di un oggetto stringa specificato `basic_string_view` o convertibile.
`find_last_of`	Cerca l'ultimo carattere che è un elemento di un oggetto stringa specificato `basic_string_view` o convertibile.
`front`	Restituisce un `const_reference` oggetto al primo elemento.
`length`	Restituisce il numero corrente di elementi.
`max_size`	Restituisce il numero massimo di caratteri che un oggetto `basic_string_view` può contenere.
`rbegin`	Restituisce un `const` iteratore che punta al primo elemento di un oggetto invertito `basic_string_view`.
`remove_prefix`	Sposta il puntatore in avanti in base al numero specificato di elementi.
`remove_suffix`	Riduce le dimensioni della visualizzazione in base al numero specificato di elementi a partire dalla parte posteriore.
`rend`	Restituisce un `const` iteratore che punta a un altro oltre l'ultimo elemento di un oggetto invertito `basic_string_view`.
`rfind`	Cerca un oggetto `basic_string_view` inverso per la prima occorrenza di una sottostringa che corrisponde a una sequenza di caratteri specificata.
`size`	Restituisce il numero corrente di elementi.
`starts_with`^C++20	Controllare se una visualizzazione stringa inizia con un prefisso specificato.
`substr`	Restituisce una sottostringa di una lunghezza specificata a partire da un indice specificato.
`swap`	Scambiare il contenuto di due `basic_string_view` oggetti.

Osservazioni:

Se viene chiesto a una funzione di generare una sequenza più lunga degli max_size elementi, la funzione segnala un errore di lunghezza generando un oggetto di tipo length_error.

Requisiti

std:c++17 o versioni successive.

Intestazione:<string_view>

Spazio dei nomistd:

`basic_string_view::at`

Restituisce un const_reference oggetto al carattere in corrispondenza dell'indice in base zero specificato.

constexpr const_reference at(size_type offset) const;

Parametri

offset
Indice dell'elemento a cui fare riferimento.

Valore restituito

Oggetto const_reference al carattere in corrispondenza della posizione specificata dall'indice del parametro.

Osservazioni:

Il primo elemento ha un indice pari a zero e gli elementi seguenti vengono indicizzati consecutivamente dagli interi positivi, in modo che una lunghezza abbia un basic_string_view elemento *n*th indicizzato dal numero n - 1.n at genera un'eccezione per indici non validi, a differenza di operator[].

In generale, è consigliabile usare at per sequenze come std::vector e basic_string_view mai. Un indice non valido passato a una sequenza è un errore logico che deve essere individuato e corretto durante lo sviluppo. Se un programma non è certo che i relativi indici siano validi, deve testarli, non chiamarli at() e basarsi su eccezioni per difendersi dalla programmazione senza attenzione.

Per ulteriori informazioni, vedere basic_string_view::operator[].

Esempio

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

Restituisce un const_reference oggetto all'ultimo elemento.

constexpr const_reference back() const;

Valore restituito

Oggetto const_reference all'ultimo elemento dell'oggetto basic_string_view.

Osservazioni:

Genera un'eccezione se l'oggetto basic_string_view è vuoto.

Tenere presente che dopo la modifica di un basic_string_view oggetto, ad esempio chiamando remove_suffix, l'elemento restituito da questa funzione non è più l'ultimo elemento nei dati sottostanti.

Esempio

Un string_view oggetto costruito con un valore letterale stringa C non include il valore Null di terminazione. Nell'esempio seguente restituisce back'p' e non '\0'.

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

I valori Null incorporati vengono considerati come qualsiasi altro carattere:

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

`basic_string_view::basic_string_view`

Costruisce un oggetto 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);

Parametri

str
Puntatore ai valori di carattere.

len
Numero di caratteri da includere nella visualizzazione.

Osservazioni:

I costruttori con un charT* parametro presuppongono che l'input sia con terminazione Null, ma il valore Null di terminazione non è incluso in basic_string_view.

È anche possibile costruire un basic_string_view oggetto con un valore letterale. Vedere operator"" sv.

`basic_string_view::begin`

Uguale a cbegin.

constexpr const_iterator begin() const noexcept;

Valore restituito

Restituisce un oggetto const_iterator che punta al primo elemento.

`basic_string_view::cbegin`

Restituisce un const_iterator oggetto che punta al primo elemento dell'intervallo.

constexpr const_iterator cbegin() const noexcept;

Valore restituito

Iteratore ad accesso casuale const che punta al primo elemento dell'intervallo o alla posizione oltre la fine di un intervallo vuoto (per un intervallo vuoto, cbegin() == cend()).

`basic_string_view::cend`

Restituisce un oggetto const_iterator che punta alla posizione immediatamente successiva all'ultimo elemento di un intervallo.

constexpr const_iterator cend() const noexcept;

Valore restituito

Iteratore const ad accesso casuale che punta oltre la fine dell'intervallo.

Osservazioni:

Il valore restituito da cend non deve essere dereferenziato.

`basic_string_view::compare`

Esegue un confronto con distinzione tra maiuscole e minuscole con un tipo stringa specificato basic_string_view (o convertibile) per determinare se i due oggetti sono uguali o se uno è lessicografico rispetto all'altro. Gli <string_view> operatori usano questa funzione membro per eseguire confronti.

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;

Parametri

strv
Oggetto basic_string_view da confrontare con questo basic_string_viewoggetto .

pos
Indice di questo basic_string_view oggetto in corrispondenza del quale inizia il confronto.

num
Numero massimo di caratteri da basic_string_view confrontare.

num2
Numero massimo di caratteri da strv confrontare.

offset
Indice di in corrispondenza del strv quale inizia il confronto.

ptr
Stringa C da confrontare con questo basic_string_viewoggetto .

Valore restituito

Valore negativo se è basic_string_view minore di strv o ptr
Zero se le due sequenze di caratteri sono uguali
Valore positivo se è basic_string_view maggiore di strv o ptr

Osservazioni:

Le compare funzioni membro eseguono un confronto con distinzione tra maiuscole e minuscole di tutte o parti di ogni sequenza di caratteri.

Esempio

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

Copia al massimo un numero specificato di caratteri da una posizione indicizzata in un'origine basic_string_view a una matrice di caratteri di destinazione. È consigliabile usare invece la funzione basic_string_view::_Copy_s protetta.

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

Parametri

ptr
Matrice di caratteri di destinazione in cui copiare gli elementi.

count
Numero massimo di caratteri da copiare dall'origine basic_string_view.

offset
Posizione iniziale nell'origine basic_string_view da cui eseguire le copie.

Valore restituito

Numero di caratteri copiati.

Osservazioni:

Un carattere Null non viene aggiunto alla fine della copia.

`basic_string_view::_Copy_s`

Funzione di copia CRT sicura da usare invece di copy.

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

Parametri

dest
Matrice di caratteri di destinazione in cui copiare gli elementi.

dest_size
La dimensione di dest.

count Numero massimo di caratteri da copiare dalla stringa di origine.

_Off
Posizione iniziale nella stringa di origine da cui effettuare le copie.

Valore restituito

Numero di caratteri copiati.

Osservazioni:

Un carattere Null non viene aggiunto alla fine della copia.

Per altre informazioni, vedere c-runtime-library/security-features-in-the-crt.

`basic_string_view::crbegin`

Restituisce un oggetto const_reverse_iterator che punta al primo elemento di un oggetto basic_string_viewinvertito.

constexpr const_reverse_iterator crbegin() const noexcept;

Valore restituito

Oggetto const_reverse_iterator che punta al primo elemento in un oggetto invertito basic_string_view.

`basic_string_view::crend`

Uguale a rend.

constexpr const_reverse_iterator crend() const noexcept;

Valore restituito

Restituisce un const_reverse_iterator oggetto che punta a un indirizzo oltre la fine di un oggetto basic_string_viewinvertito.

`basic_string_view::data`

Restituisce un puntatore non proprietario non elaborato alla sequenza di caratteri const dell'oggetto utilizzato per costruire l'oggetto basic_string_view.

constexpr value_type *data() const noexcept;

Valore restituito

Puntatore a const al primo elemento della sequenza di caratteri.

Osservazioni:

Il puntatore non può modificare i caratteri.

Una sequenza di basic_string_view caratteri non è necessariamente con terminazione Null. Il tipo restituito per data non è una stringa C valida, perché non viene aggiunto alcun carattere Null. Il carattere \0 Null non ha alcun significato speciale in un oggetto di tipo basic_string_view e può essere parte dell'oggetto basic_string_view esattamente come qualsiasi altro carattere.

`basic_string_view::empty`

Verifica se contiene basic_string_view o meno caratteri.

constexpr bool empty() const noexcept;

Valore restituito

true se l'oggetto basic_string_view non contiene caratteri; false se ha almeno un carattere.

Osservazioni:

La funzione membro equivale a size() == 0.

`basic_string_view::end`

Restituisce un accesso const_iterator casuale che punta a un elemento precedente all'ultimo elemento.

constexpr const_iterator end() const noexcept;

Valore restituito

Restituisce un accesso const_iterator casuale che punta a un elemento precedente all'ultimo elemento.

Osservazioni:

end viene utilizzato per verificare se un oggetto const_iterator ha raggiunto la fine del relativo basic_string_viewoggetto . Il valore restituito da end non deve essere dereferenziato.

`basic_string_view::ends_with`

Controllare se la visualizzazione stringa termina con il suffisso specificato.

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;

Parametri

c
Suffisso a carattere singolo da cercare.

sv
Visualizzazione stringa contenente il suffisso da cercare.
È possibile passare un std::basic_stringoggetto , che converte in un oggetto basic_string_view.

x
Stringa di caratteri con terminazione Null contenente il suffisso da cercare.

Valore restituito

true se la visualizzazione stringa termina con il suffisso specificato; false Altrimenti.

Osservazioni:

ends_with() è una novità di C++20. Per usarlo, specificare l'opzione del /std:c++20 compilatore o versione successiva.

Verificare starts_with se una visualizzazione stringa inizia con il prefisso specificato.

Esempio

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

Cerca in basic_string_view una direzione in avanti la prima occorrenza di un carattere o di una sottostringa che corrisponde a una sequenza di caratteri specificata.

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;

Parametri

str
Oggetto basic_string_view per il quale la funzione membro deve eseguire la ricerca.

chVal
Valore di carattere che la funzione membro deve cercare.

offset
Indice in corrispondenza del quale iniziare la ricerca.

ptr
Stringa C per la quale la funzione membro deve eseguire la ricerca.

count
Numero di caratteri in ptr, contando in avanti dal primo carattere.

Valore restituito

Indice del primo carattere della sottostringa ricercata; in caso contrario npos.

`basic_string_view::find_first_not_of`

Cerca il primo carattere che non è un elemento di un oggetto stringa specificato basic_string_view o convertibile.

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;

Parametri

str
Oggetto basic_string_view per il quale la funzione membro deve eseguire la ricerca.

chVal
Valore di carattere che la funzione membro deve cercare.

offset
Indice in corrispondenza del quale iniziare la ricerca.

ptr
Stringa C per la quale la funzione membro deve eseguire la ricerca.

count
Numero di caratteri, contando in avanti dal primo carattere, nella stringa C in cui la funzione membro deve eseguire la ricerca.

Valore restituito

Indice del primo carattere della sottostringa ricercata; in caso contrario npos.

`basic_string_view::find_first_of`

Cerca il primo carattere che corrisponde a qualsiasi elemento di un oggetto specificato basic_string_view.

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

Parametri

chVal
Valore di carattere che la funzione membro deve cercare.

offset
Indice in corrispondenza del quale iniziare la ricerca.

ptr
Stringa C per la quale la funzione membro deve eseguire la ricerca.

count
Numero di caratteri, contando in avanti dal primo carattere, nella stringa C in cui la funzione membro deve eseguire la ricerca.

str
Oggetto basic_string_view per il quale la funzione membro deve eseguire la ricerca.

Valore restituito

Indice del primo carattere della sottostringa ricercata; in caso contrario npos.

`basic_string_view::find_last_not_of`

Cerca l'ultimo carattere che non è alcun elemento di un oggetto specificato basic_string_view.

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

Parametri

str
Oggetto basic_string_view per il quale la funzione membro deve eseguire la ricerca.

chVal
Valore di carattere che la funzione membro deve cercare.

offset
Indice in corrispondenza del quale deve essere completata la ricerca.

ptr
Stringa C per la quale la funzione membro deve eseguire la ricerca.

count
Numero di caratteri, contando in avanti dal primo carattere, in ptr.

Valore restituito

Indice del primo carattere della sottostringa ricercata; in caso contrario string_view::npos.

`basic_string_view::find_last_of`

Cerca l'ultimo carattere che corrisponde a qualsiasi elemento di un oggetto specificato basic_string_view.

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

Parametri

str
Oggetto basic_string_view per il quale la funzione membro deve eseguire la ricerca.

chVal
Valore di carattere che la funzione membro deve cercare.

offset
Indice in corrispondenza del quale deve essere completata la ricerca.

ptr
Stringa C per la quale la funzione membro deve eseguire la ricerca.

count
Numero di caratteri, contando in avanti dal primo carattere, nella stringa C in cui la funzione membro deve eseguire la ricerca.

Valore restituito

Indice dell'ultimo carattere della sottostringa trovato; se la ricerca ha esito negativo, npos.

`basic_string_view::front`

Restituisce un const_reference oggetto al primo elemento.

constexpr const_reference front() const;

Valore restituito

Oggetto const_reference al primo elemento.

Osservazioni:

Genera un'eccezione se l'oggetto basic_string_view è vuoto.

`basic_string_view::length`

Restituisce il numero corrente di elementi.

constexpr size_type length() const noexcept;

Osservazioni:

La funzione membro è uguale sizea .

`basic_string_view::max_size`

Restituisce il numero massimo di caratteri che un basic_string_view oggetto può contenere.

constexpr size_type max_size() const noexcept;

Valore restituito

Numero massimo di caratteri che un basic_string_view oggetto può contenere.

Osservazioni:

Viene generata un'eccezione di tipo length_error quando un'operazione produce un oggetto basic_string_view con lunghezza maggiore di max_size().

`basic_string_view::operator=`

Assegna un basic_string_view oggetto stringa convertibile o a un altro basic_string_viewoggetto .

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

Esempio

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

`basic_string_view::operator[]`

Fornisce un const_reference oggetto al carattere con un indice specificato.

constexpr const_reference operator[](size_type offset) const;

Parametri

offset
Indice dell'elemento a cui fare riferimento.

Valore restituito

Oggetto const_reference al carattere in corrispondenza della posizione specificata dall'indice del parametro.

Osservazioni:

Il primo elemento ha un indice pari a zero e gli elementi seguenti vengono indicizzati consecutivamente dagli interi positivi, in modo che una di lunghezza abbia un basic_string_view elemento *n*th indicizzato dal numero n-1.n

operator[] è più veloce della funzione at membro per fornire l'accesso in lettura agli elementi di un oggetto basic_string_view.

operator[] non verifica se l'indice passato come argomento è valido. Un indice non valido passato a restituisce operator[] un comportamento non definito.

Il riferimento restituito può essere invalidato se i dati della stringa sottostante vengono modificati o eliminati dall'oggetto proprietario.

Durante la compilazione con _ITERATOR_DEBUG_LEVEL impostato su 1 o 2, si verificherà un errore di runtime se si tenta di accedere a un elemento al di fuori dei limiti di basic_string_view. Per altre informazioni, vedere Checked Iterators.

`basic_string_view::rbegin`

Restituisce un const iteratore al primo elemento di un oggetto invertito basic_string_view.

constexpr const_reverse_iterator rbegin() const noexcept;

Valore restituito

Restituisce un iteratore ad accesso casuale al primo elemento di un oggetto invertito basic_string_view, che punta all'ultimo elemento dell'oggetto corrispondente non invertito basic_string_view.

Osservazioni:

rbegin viene usato con un oggetto invertito basic_string_view esattamente come begin viene usato con un oggetto basic_string_view. rbegin può essere usato per inizializzare un'iterazione all'indietro.

`basic_string_view::remove_prefix`

Sposta il puntatore in avanti in base al numero specificato di elementi.

constexpr void remove_prefix(size_type n);

Osservazioni:

Lascia invariati i dati sottostanti. Sposta il basic_string_view puntatore in avanti per n elementi e imposta il membro dati privato size su size - n.

`basic_string_view::remove_suffix`

Riduce le dimensioni della visualizzazione in base al numero specificato di elementi a partire dalla parte posteriore.

constexpr void remove_suffix(size_type n);

Osservazioni:

Lascia invariati i dati sottostanti e il puntatore. Imposta il membro dati privato size su size - n.

`basic_string_view::rend`

Restituisce un const iteratore che punta a un altro oltre l'ultimo elemento di un oggetto invertito basic_string_view.

constexpr reverse_iterator rend() const noexcept;

Valore restituito

Iteratore const ad accesso casuale inverso che punta a un altro oltre l'ultimo elemento di un oggetto invertito basic_string_view.

Osservazioni:

rend viene usato con un oggetto invertito basic_string_view esattamente come end viene usato con un oggetto basic_string_view. rend può essere usato per verificare se un iteratore inverso ha raggiunto la fine del relativo basic_string_view. Il valore restituito da rend non deve essere dereferenziato.

`basic_string_view::rfind`

Cerca una basic_string_view sottostringa inversa che corrisponde a una sequenza di caratteri specificata.

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;

Parametri

chVal
Valore di carattere che la funzione membro deve cercare.

offset
Indice in corrispondenza del quale iniziare la ricerca.

ptr
Stringa C per la quale la funzione membro deve eseguire la ricerca.

count
Numero di caratteri, contando in avanti dal primo carattere, nella stringa C in cui la funzione membro deve eseguire la ricerca.

str
Oggetto basic_string_view per il quale la funzione membro deve eseguire la ricerca.

Valore restituito

Indice del primo carattere della sottostringa quando ha esito positivo; in caso contrario npos, .

`basic_string_view::size`

Restituisce il numero di elementi nel basic_string_view.

constexpr size_type size() const noexcept;

Valore restituito

Lunghezza dell'oggetto basic_string_view.

Osservazioni:

Un basic_string_view oggetto può modificarne la lunghezza, ad esempio in remove_prefix base a e remove_suffix. Poiché ciò non modifica i dati stringa sottostanti, le dimensioni di un basic_string_view oggetto non sono necessariamente le dimensioni dei dati sottostanti.

`basic_string_view::starts_with`

Controllare se la visualizzazione stringa inizia con il prefisso specificato.

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;

Parametri

c
Prefisso di carattere singolo da cercare.

sv
Visualizzazione stringa contenente il prefisso da cercare.
È possibile passare un std::basic_stringoggetto , che viene convertito in una visualizzazione stringa.

x
Stringa di caratteri con terminazione Null contenente il prefisso da cercare.

Valore restituito

true se la stringa inizia con il prefisso specificato; false Altrimenti.

Osservazioni:

starts_with() è una novità di C++20. Per usarlo, specificare l'opzione del std:c++20 compilatore o versione successiva.

Vedere ends_with se una stringa termina con un suffisso.

Esempio

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

Restituisce un basic_string_view oggetto che rappresenta (al massimo) il numero specificato di caratteri da una posizione specificata.

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

Parametri

offset
Indice che individua l'elemento in corrispondenza della posizione da cui viene eseguita la copia, con un valore predefinito pari a 0.

count
Numero di caratteri da includere nella sottostringa, se presenti.

Valore restituito

Oggetto basic_string_view che rappresenta la sottosequenza specificata degli elementi.

`basic_string_view::swap`

Scambia due basic_string_views, in altre parole i puntatori ai dati stringa sottostanti e i valori delle dimensioni.

constexpr void swap(basic_string_view& sv) noexcept;

Parametri

sv
basic_string_view Origine i cui valori puntatore e dimensione devono essere scambiati con quello della destinazione basic_string_view.

Vedi anche

<string_view>
Thread Safety in the C++ Standard Library (Sicurezza dei thread nella libreria standard C++)

Condividi tramite

Classe basic_string_view

Sintassi

Parametri

Costruttori

Typedef

Operatori membro

Funzioni membro

Osservazioni:

Requisiti

basic_string_view::at

Parametri

Valore restituito

Osservazioni:

Esempio

basic_string_view::back

Valore restituito

Osservazioni:

Esempio

basic_string_view::basic_string_view

Parametri

Osservazioni:

basic_string_view::begin

Valore restituito

basic_string_view::cbegin

Valore restituito

basic_string_view::cend

Valore restituito

Osservazioni:

basic_string_view::compare

Parametri

Valore restituito

Osservazioni:

Esempio

basic_string_view::copy

Parametri

Valore restituito

Osservazioni:

basic_string_view::_Copy_s

Parametri

Valore restituito

Osservazioni:

basic_string_view::crbegin

Valore restituito

basic_string_view::crend

Valore restituito

basic_string_view::data

Valore restituito

Osservazioni:

basic_string_view::empty

Valore restituito

Osservazioni:

basic_string_view::end

Valore restituito

Osservazioni:

basic_string_view::ends_with

Parametri

Valore restituito

Osservazioni:

Esempio

basic_string_view::find

Parametri

Valore restituito

basic_string_view::find_first_not_of

Parametri

Valore restituito

basic_string_view::find_first_of

Parametri

Valore restituito

basic_string_view::find_last_not_of

Parametri

Valore restituito

basic_string_view::find_last_of

Parametri

Valore restituito

basic_string_view::front

Valore restituito

Osservazioni:

basic_string_view::length

Osservazioni:

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