Classe `basic_string_view`

Article
10/12/2023

Le modèle basic_string_view<charT> de classe a été ajouté en C++17 pour servir de moyen sûr et efficace pour une fonction d’accepter différents types de chaînes non liés sans que la fonction ne soit templatée sur ces types. La classe contient un pointeur non propriétaire vers une séquence contiguë de données de caractères et une longueur qui spécifie le nombre de caractères dans la séquence. Aucune hypothèse n’est faite sur la question de savoir si la séquence est terminée par null.

La bibliothèque standard définit plusieurs spécialisations en fonction du type des éléments :

string_view
wstring_view
u16string_view
u32string_view

A basic_string_view décrit l’interface minimale courante nécessaire pour lire les données de chaîne. Il fournit un accès const aux données sous-jacentes ; il n’effectue aucune copie (à l’exception de la copy fonction). Les données peuvent contenir ou non des valeurs Null (\0) à n’importe quelle position. Un basic_string_view contrôle n’a aucun contrôle sur la durée de vie de l’objet. Il incombe à l’appelant de s’assurer que les données de chaîne sous-jacentes sont valides.

Une fonction qui accepte un paramètre de type string_view peut être effectuée pour fonctionner avec n’importe quel type de type de type chaîne, sans rendre la fonction dans un modèle, ou limiter la fonction à un sous-ensemble particulier de types de chaînes. La seule exigence est qu’une conversion implicite existe du type de chaîne en string_view. Tous les types de chaînes standard sont implicitement convertibles en un string_view qui contient le même type d’élément. En d’autres termes, un std::string est convertible en un string_view mais pas à un wstring_view.

L’exemple suivant montre une fonction f non-modèle qui prend un paramètre de type wstring_view. Il peut être appelé avec des arguments de type std::wstring, wchar_t*et 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;

Paramètres

CharType
Type des caractères stockés dans le basic_string_view. La bibliothèque standard C++ fournit les typesdefs suivants pour les spécialisations de ce modèle.

string_view pour les éléments de type char
wstring_viewpour wchar_t
u16string_view pour char16_t
u32string_view plutôt que char32_t

Traits
La valeur par défaut est char_traits<CharType>.

Constructeurs

Constructeur	Description
`basic_string_view`	Construit un `basic_string_view` élément vide ou autre pointe vers toutes ou partie des données d’un autre objet de chaîne, ou vers un tableau de caractères de style C.

Typedefs

Nom de type	Description
`const_iterator`	Itérateur d’accès aléatoire qui peut lire `const` des éléments.
`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;`

Opérateurs membres

Opérateur	Description
`operator=`	Affecte un objet de chaîne convertible à un `basic_string_view` autre `basic_string_view`objet .
`operator[]`	Retourne l'élément à l'index spécifié.

Fonctions Membre

Fonction membre	Description
`at`	Retourne un `const_reference` élément à un emplacement spécifié.
`back`	Retourne un `const_reference` au dernier élément.
`begin`	Retourne un `const` itérateur qui traite le premier élément. (`basic_string_view`s sont immuables.)
`cbegin`	Comme pour `begin`.
`cend`	Retourne un `const` itérateur qui pointe vers un dernier élément.
`copy`	Copie au plus un nombre spécifié de caractères d’une position indexée dans une source `basic_string_view` vers un tableau de caractères cible. (Non recommandé. Utilisez `_Copy_s` plutôt.)
`_Copy_s`	Fonction de copie CRT sécurisée.
`compare`	Compare un `basic_string_view` avec un spécifié `basic_string_view` pour déterminer s’ils sont égaux ou si l’un est lexicographiquement inférieur à l’autre.
`crbegin`	Comme pour `rbegin`.
`crend`	Comme pour `rend`.
`data`	Retourne un pointeur non propriétaire brut vers la séquence de caractères.
`empty`	Teste si les `basic_string_view` caractères contiennent des caractères.
`end`	Comme pour `cend`.
`ends_with`^C++20	Vérifiez si une vue de chaîne se termine par un suffixe spécifié.
`find`	Recherche dans une direction vers l’avant la première occurrence d’une sous-chaîne qui correspond à une séquence de caractères spécifiée.
`find_first_not_of`	Recherche le premier caractère qui n’est pas un élément d’un objet de chaîne spécifié `basic_string_view` ou convertible.
`find_first_of`	Recherche le premier caractère qui correspond à n’importe quel élément d’un objet de chaîne spécifié `basic_string_view` ou convertible.
`find_last_not_of`	Recherche le dernier caractère qui n’est pas un élément d’un objet de chaîne spécifié `basic_string_view` ou convertible.
`find_last_of`	Recherche le dernier caractère qui est un élément d’un objet de chaîne spécifié `basic_string_view` ou convertible.
`front`	Retourne un `const_reference` élément au premier élément.
`length`	Retourne le nombre actuel d’éléments.
`max_size`	Retourne le nombre maximal de caractères qu’un `basic_string_view` peut contenir.
`rbegin`	Retourne un `const` itérateur qui traite le premier élément d’un élément inversé `basic_string_view`.
`remove_prefix`	Déplace le pointeur vers l’avant par le nombre spécifié d’éléments.
`remove_suffix`	Réduit la taille de l’affichage par le nombre spécifié d’éléments à partir du dos.
`rend`	Retourne un `const` itérateur qui pointe vers un dernier élément d’un élément inversé `basic_string_view`.
`rfind`	Recherche à `basic_string_view` l’inverse la première occurrence d’une sous-chaîne qui correspond à une séquence de caractères spécifiée.
`size`	Retourne le nombre actuel d’éléments.
`starts_with`^C++20	Vérifiez si une vue de chaîne commence par un préfixe donné.
`substr`	Retourne une sous-chaîne d’une longueur spécifiée commençant à un index spécifié.
`swap`	Échangez le contenu de deux `basic_string_view` objets.

Notes

Si une fonction est invitée à générer une séquence plus longue que les max_size éléments, la fonction signale une erreur de longueur en lève un objet de type length_error.

Spécifications

std:c++17 ou une version ultérieure.

En-tête: <string_view>

Espace de noms : std

`basic_string_view::at`

Retourne un const_reference caractère à l’index de base zéro spécifié.

constexpr const_reference at(size_type offset) const;

Paramètres

offset
Index de l’élément à référencer.

Valeur retournée

Vers const_reference le caractère à la position spécifiée par l’index de paramètre.

Notes

Le premier élément a un index de zéro et les éléments suivants sont indexés consécutivement par les entiers positifs, de sorte qu’une basic_string_view longueur a un *n*ième élément indexé par le nombre n - 1n . at lève une exception pour les index non valides, contrairement operator[]à .

En général, nous vous recommandons de at ne jamais utiliser les séquences telles que std::vector celles basic_string_view qui ne doivent jamais être utilisées. Un index non valide passé à une séquence est une erreur logique qui doit être découverte et corrigée pendant le développement. Si un programme n’est pas certain que ses index sont valides, il doit les tester, ne pas appeler at() et s’appuyer sur des exceptions pour se défendre contre la programmation insouciante.

Pour plus d’informations, consultez basic_string_view::operator[].

Exemple

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

Retourne un const_reference au dernier élément.

constexpr const_reference back() const;

Valeur retournée

Vers const_reference le dernier élément dans le basic_string_view.

Notes

Lève une exception si la valeur basic_string_view est vide.

N’oubliez pas qu’après une basic_string_view modification, par exemple en appelant remove_suffix, l’élément retourné par cette fonction n’est plus le dernier élément des données sous-jacentes.

Exemple

Une string_view valeur construite avec un littéral de chaîne C n’inclut pas la valeur Null de fin. Par conséquent, dans l’exemple suivant, back retourne 'p' et non '\0'.

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

Les valeurs null incorporées sont traitées comme n’importe quel autre caractère :

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

`basic_string_view::basic_string_view`

Construit un objet 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);

Paramètres

str
Pointeur vers les valeurs de caractères.

len
Nombre de caractères à inclure dans la vue.

Notes

Les constructeurs avec un charT* paramètre supposent que l’entrée est terminée par null, mais que la valeur null de fin n’est pas incluse dans le basic_string_view.

Vous pouvez également construire un basic_string_view littéral. Consultez l’article operator"" sv.

`basic_string_view::begin`

Comme pour cbegin.

constexpr const_iterator begin() const noexcept;

Valeur retournée

Retourne un const_iterator adressage du premier élément.

`basic_string_view::cbegin`

Retourne un const_iterator élément qui traite le premier élément de la plage.

constexpr const_iterator cbegin() const noexcept;

Valeur retournée

Itérateur d'accès aléatoire const qui pointe vers le premier élément de la plage, ou vers l'emplacement situé juste après la fin d'une plage vide (pour une plage vide : cbegin() == cend()).

`basic_string_view::cend`

Retourne une const_iterator valeur qui traite l’emplacement juste au-delà du dernier élément d’une plage.

constexpr const_iterator cend() const noexcept;

Valeur retournée

Itérateur d'accès aléatoire const qui pointe juste après la fin de la plage.

Notes

La valeur retournée par cend ne doit pas être déréférencement.

`basic_string_view::compare`

Effectue une comparaison sensible à la casse avec un type de chaîne spécifié basic_string_view (ou convertible) pour déterminer si les deux objets sont égaux ou si l’un est lexicographiquement inférieur à l’autre. Les <string_view> opérateurs utilisent cette fonction membre pour effectuer des comparaisons.

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;

Paramètres

strv
Ce basic_string_view qui doit être comparé à ceci basic_string_view.

pos
Index de ce basic_string_view qui commence par la comparaison.

num
Nombre maximal de caractères de cette basic_string_view valeur à comparer.

num2
Nombre maximal de caractères strv à comparer.

offset
Index de début de strv la comparaison.

ptr
Chaîne C à comparer à ceci basic_string_view.

Valeur retournée

Valeur négative si elle basic_string_view est inférieure strv ou ptr
Zéro si les deux séquences de caractères sont égales
Valeur positive si celle-ci basic_string_view est supérieure strv ou ptr

Notes

Les compare fonctions membres effectuent une comparaison sensible à la casse de l’ensemble ou de la partie de chaque séquence de caractères.

Exemple

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

Copie au plus un nombre spécifié de caractères d’une position indexée dans une source basic_string_view vers un tableau de caractères cible. Nous vous recommandons d’utiliser la fonction basic_string_view::_Copy_s sécurisée à la place.

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

Paramètres

ptr
Tableau de caractères cible dans lequel les éléments doivent être copiés.

count
Nombre de caractères à copier, au plus, à partir de la source basic_string_view.

offset
Position de début dans la source basic_string_view à partir de laquelle des copies doivent être effectuées.

Valeur retournée

Nombre de caractères copiés.

Notes

Un caractère Null n’est pas ajouté à la fin de la copie.

`basic_string_view::_Copy_s`

Sécuriser la fonction de copie CRT à utiliser au lieu de copy.

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

Paramètres

dest
Tableau de caractères cible dans lequel les éléments doivent être copiés.

dest_size
Taille de dest.

count Nombre de caractères à copier, au plus, à partir de la chaîne source.

_Off
Position de début dans la chaîne source à partir de laquelle les copies doivent être effectuées.

Valeur retournée

Nombre de caractères copiés.

Notes

Un caractère Null n’est pas ajouté à la fin de la copie.

Pour plus d’informations, consultez c-runtime-library/security-features-in-the-crt.

`basic_string_view::crbegin`

Retourne un const_reverse_iterator qui traite le premier élément d’un élément inversé basic_string_view.

constexpr const_reverse_iterator crbegin() const noexcept;

Valeur retournée

Qui const_reverse_iterator traite le premier élément d’un inverse basic_string_view.

`basic_string_view::crend`

Comme pour rend.

constexpr const_reverse_iterator crend() const noexcept;

Valeur retournée

Retourne un const_reverse_iterator qui s’adresse un après la fin d’un inverse basic_string_view.

`basic_string_view::data`

Retourne un pointeur non propriétaire brut vers la séquence de caractères const de l’objet utilisé pour construire le basic_string_view.

constexpr value_type *data() const noexcept;

Valeur retournée

Pointeur vers const vers le premier élément de la séquence de caractères.

Notes

Le pointeur ne peut pas modifier les caractères.

Une séquence de basic_string_view caractères n’est pas nécessairement terminée par null. Le type de retour pour data n’est pas une chaîne C valide, car aucun caractère Null n’est ajouté. Le caractère \0 Null n’a aucune signification particulière dans un objet de type basic_string_view et peut être une partie de l’objet basic_string_view comme n’importe quel autre caractère.

`basic_string_view::empty`

Teste si les basic_string_view caractères contiennent ou non.

constexpr bool empty() const noexcept;

Valeur retournée

true si l’objet basic_string_view ne contient aucun caractère ; false s’il a au moins un caractère.

Notes

La fonction membre est équivalente à size() == 0.

`basic_string_view::end`

Retourne un accès const_iterator aléatoire qui pointe vers un dernier élément.

constexpr const_iterator end() const noexcept;

Valeur retournée

Retourne un accès const_iterator aléatoire qui pointe vers un dernier élément.

Notes

end est utilisé pour tester si un const_iterator a atteint la fin de son basic_string_view. La valeur retournée par end ne doit pas être déréférencement.

`basic_string_view::ends_with`

Vérifiez si la vue de chaîne se termine par le suffixe spécifié.

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;

Paramètres

c
Suffixe de caractère unique à rechercher.

sv
Vue de chaîne contenant le suffixe à rechercher.
Vous pouvez passer un std::basic_string, qui se convertit en .basic_string_view

x
Chaîne de caractères terminée par null contenant le suffixe à rechercher.

Valeur retournée

true si la vue de chaîne se termine par le suffixe spécifié ; false autrement.

Notes

ends_with() est nouveau en C++20. Pour l’utiliser, spécifiez l’option du /std:c++20 compilateur ou ultérieure.

Pour starts_with vérifier si une vue de chaîne commence par le préfixe spécifié.

Exemple

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

Recherche dans une basic_string_view direction vers l’avant la première occurrence d’un caractère ou d’une sous-chaîne qui correspond à une séquence de caractères spécifiée.

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;

Paramètres

str
Pour basic_string_view lequel la fonction membre doit effectuer une recherche.

chVal
Valeur de caractère que la fonction membre doit rechercher.

offset
Index auquel la recherche doit commencer.

ptr
Chaîne C pour laquelle la fonction membre doit effectuer une recherche.

count
Nombre de caractères dans ptr, en comptant vers l’avant à partir du premier caractère.

Valeur retournée

Index du premier caractère de la sous-chaîne recherchée en cas de succès ; dans le cas contraire, npos.

`basic_string_view::find_first_not_of`

Recherche le premier caractère qui n’est pas un élément d’un objet de chaîne spécifié basic_string_view ou convertible.

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;

Paramètres

str
Pour basic_string_view lequel la fonction membre doit effectuer une recherche.

chVal
Valeur de caractère que la fonction membre doit rechercher.

offset
Index auquel la recherche doit commencer.

ptr
Chaîne C pour laquelle la fonction membre doit effectuer une recherche.

count
Nombre de caractères, en comptant vers l’avant à partir du premier caractère, dans la chaîne C pour laquelle la fonction membre doit effectuer une recherche.

Valeur retournée

Index du premier caractère de la sous-chaîne recherchée en cas de succès ; dans le cas contraire, npos.

`basic_string_view::find_first_of`

Recherche le premier caractère qui correspond à n’importe quel élément d’un élément spécifié 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;

Paramètres

chVal
Valeur de caractère que la fonction membre doit rechercher.

offset
Index auquel la recherche doit commencer.

ptr
Chaîne C pour laquelle la fonction membre doit effectuer une recherche.

count
Nombre de caractères, en comptant vers l’avant à partir du premier caractère, dans la chaîne C pour laquelle la fonction membre doit effectuer une recherche.

str
Pour basic_string_view lequel la fonction membre doit effectuer une recherche.

Valeur retournée

Index du premier caractère de la sous-chaîne recherchée en cas de succès ; dans le cas contraire, npos.

`basic_string_view::find_last_not_of`

Recherche le dernier caractère qui n’est pas un élément d’un élément spécifié 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;

Paramètres

str
Pour basic_string_view lequel la fonction membre doit effectuer une recherche.

chVal
Valeur de caractère que la fonction membre doit rechercher.

offset
Index auquel la recherche doit se terminer.

ptr
Chaîne C pour laquelle la fonction membre doit effectuer une recherche.

count
Nombre de caractères, comptant vers l’avant à partir du premier caractère, en ptr.

Valeur retournée

Index du premier caractère de la sous-chaîne recherchée en cas de succès ; dans le cas contraire, string_view::npos.

`basic_string_view::find_last_of`

Recherche le dernier caractère qui correspond à n’importe quel élément d’un élément spécifié 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;

Paramètres

str
Pour basic_string_view lequel la fonction membre doit effectuer une recherche.

chVal
Valeur de caractère que la fonction membre doit rechercher.

offset
Index auquel la recherche doit se terminer.

ptr
Chaîne C pour laquelle la fonction membre doit effectuer une recherche.

count
Nombre de caractères, en comptant vers l’avant à partir du premier caractère, dans la chaîne C pour laquelle la fonction membre doit effectuer une recherche.

Valeur retournée

Index du dernier caractère de la sous-chaîne recherchée en cas de réussite ; sinon, npos.

`basic_string_view::front`

Retourne un const_reference élément au premier élément.

constexpr const_reference front() const;

Valeur retournée

A const_reference au premier élément.

Notes

Lève une exception si la valeur basic_string_view est vide.

`basic_string_view::length`

Retourne le nombre actuel d’éléments.

constexpr size_type length() const noexcept;

Notes

La fonction membre est la même que size.

`basic_string_view::max_size`

Retourne le nombre maximal de caractères qu’un basic_string_view peut contenir.

constexpr size_type max_size() const noexcept;

Valeur retournée

Nombre maximal de caractères qu’un basic_string_view peut contenir.

Notes

Une exception de type length_error est levée lorsqu’une opération produit une basic_string_view longueur supérieure max_size()à .

`basic_string_view::operator=`

Affecte un objet de chaîne convertible à un basic_string_view autre basic_string_viewobjet .

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

Exemple

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

`basic_string_view::operator[]`

Fournit un const_reference caractère avec un index spécifié.

constexpr const_reference operator[](size_type offset) const;

Paramètres

offset
Index de l’élément à référencer.

Valeur retournée

Vers const_reference le caractère à la position spécifiée par l’index de paramètre.

Notes

Le premier élément a un index de zéro et les éléments suivants sont indexés consécutivement par les entiers positifs, de sorte qu’une basic_string_view longueur n a un *n*ième élément indexé par le nombre n-1.

operator[] est plus rapide que la fonction at membre pour fournir un accès en lecture aux éléments d’un basic_string_view.

operator[] ne vérifie pas si l’index passé en tant qu’argument est valide. Un index non valide passé pour operator[] entraîner un comportement non défini.

La référence retournée peut être invalidée si les données de chaîne sous-jacentes sont modifiées ou supprimées par l’objet propriétaire.

Lors de la compilation avec _ITERATOR_DEBUG_LEVEL la valeur 1 ou 2, une erreur d’exécution se produit si vous tentez d’accéder à un élément en dehors des limites du basic_string_view. Pour plus d'informations, consultez Checked Iterators.

`basic_string_view::rbegin`

Retourne un const itérateur au premier élément d’un élément inversé basic_string_view.

constexpr const_reverse_iterator rbegin() const noexcept;

Valeur retournée

Retourne un itérateur d’accès aléatoire au premier élément d’un élément inversé, ciblant ce qui serait le dernier élément dans l’élément non basic_string_viewinversé basic_string_viewcorrespondant.

Notes

rbegin est utilisé avec un inverse basic_string_view comme begin utilisé avec un basic_string_view. rbegin peut être utilisé pour initialiser une itération vers l’arrière.

`basic_string_view::remove_prefix`

Déplace le pointeur vers l’avant par le nombre spécifié d’éléments.

constexpr void remove_prefix(size_type n);

Notes

Laisse les données sous-jacentes inchangées. Déplace le pointeur vers l’avant basic_string_view par n les éléments et définit le membre de données privé size sur size - n.

`basic_string_view::remove_suffix`

Réduit la taille de l’affichage par le nombre spécifié d’éléments à partir du dos.

constexpr void remove_suffix(size_type n);

Notes

Laisse les données sous-jacentes et le pointeur vers celui-ci inchangé. Définit le membre de données privé size sur size - n.

`basic_string_view::rend`

Retourne un const itérateur qui pointe vers un dernier élément d’un élément inversé basic_string_view.

constexpr reverse_iterator rend() const noexcept;

Valeur retournée

Itérateur const d’accès aléatoire inverse qui pointe vers un dernier élément d’un élément inversé basic_string_view.

Notes

rend est utilisé avec un inverse basic_string_view comme end utilisé avec un basic_string_view. rend peut être utilisé pour tester si un itérateur inverse a atteint la fin de son basic_string_view. La valeur retournée par rend ne doit pas être déréférencement.

`basic_string_view::rfind`

Recherche à l’inverse une basic_string_view sous-chaîne qui correspond à une séquence de caractères spécifiée.

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;

Paramètres

chVal
Valeur de caractère que la fonction membre doit rechercher.

offset
Index auquel la recherche doit commencer.

ptr
Chaîne C pour laquelle la fonction membre doit effectuer une recherche.

count
Nombre de caractères, en comptant vers l’avant à partir du premier caractère, dans la chaîne C pour laquelle la fonction membre doit effectuer une recherche.

str
Pour basic_string_view lequel la fonction membre doit effectuer une recherche.

Valeur retournée

Index du premier caractère de la sous-chaîne en cas de réussite ; sinon npos.

`basic_string_view::size`

Retourne le nombre d'éléments d'un basic_string_view.

constexpr size_type size() const noexcept;

Valeur retournée

Longueur du basic_string_view.

Notes

A basic_string_view peut modifier sa longueur, par exemple par remove_prefix et remove_suffix. Comme cela ne modifie pas les données de chaîne sous-jacentes, la taille d’un basic_string_view n’est pas nécessairement la taille des données sous-jacentes.

`basic_string_view::starts_with`

Vérifiez si la vue de chaîne commence par le préfixe spécifié.

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;

Paramètres

c
Préfixe de caractère unique à rechercher.

sv
Vue de chaîne contenant le préfixe à rechercher.
Vous pouvez passer un std::basic_string, qui se convertit en vue de chaîne.

x
Chaîne de caractères terminée par null contenant le préfixe à rechercher.

Valeur retournée

true si la chaîne commence par le préfixe spécifié ; false autrement.

Notes

starts_with() est nouveau en C++20. Pour l’utiliser, spécifiez l’option du std:c++20 compilateur ou ultérieure.

Voir ends_with si une chaîne se termine par un suffixe.

Exemple

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

Retourne un basic_string_view qui représente (au plus) le nombre spécifié de caractères à partir d’une position spécifiée.

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

Paramètres

offset
Index localisant l’élément à la position à partir de laquelle la copie est effectuée, avec une valeur par défaut de 0.

count
Nombre de caractères à inclure dans la sous-chaîne, s’ils sont présents.

Valeur retournée

Objet basic_string_view qui représente la sous-séquence spécifiée des éléments.

`basic_string_view::swap`

Échange deux basic_string_views, en d’autres termes, les pointeurs vers les données de chaîne sous-jacentes et les valeurs de taille.

constexpr void swap(basic_string_view& sv) noexcept;

Paramètres

sv
Source basic_string_view dont les valeurs de pointeur et de taille doivent être échangées avec celle de la destination basic_string_view.

Voir aussi

<string_view>
Sécurité des threads dans la bibliothèque C++ Standard

Partage via

Classe basic_string_view

Syntaxe

Paramètres

Constructeurs

Typedefs

Opérateurs membres

Fonctions Membre

Notes

Spécifications

basic_string_view::at

Paramètres

Valeur retournée

Notes

Exemple

basic_string_view::back

Valeur retournée

Notes

Exemple

basic_string_view::basic_string_view

Paramètres

Notes

basic_string_view::begin

Valeur retournée

basic_string_view::cbegin

Valeur retournée

basic_string_view::cend

Valeur retournée

Notes

basic_string_view::compare

Paramètres

Valeur retournée

Notes

Exemple

basic_string_view::copy

Paramètres

Valeur retournée

Notes

basic_string_view::_Copy_s

Paramètres

Valeur retournée

Notes

basic_string_view::crbegin

Valeur retournée

basic_string_view::crend

Valeur retournée

basic_string_view::data

Valeur retournée

Notes

basic_string_view::empty

Valeur retournée

Notes

basic_string_view::end

Valeur retournée

Notes

basic_string_view::ends_with

Paramètres

Valeur retournée

Notes

Exemple

basic_string_view::find

Paramètres

Valeur retournée

basic_string_view::find_first_not_of

Paramètres

Valeur retournée

basic_string_view::find_first_of

Paramètres

Valeur retournée

basic_string_view::find_last_not_of

Paramètres

Valeur retournée

basic_string_view::find_last_of

Paramètres

Valeur retournée

basic_string_view::front

Valeur retournée

Notes

basic_string_view::length

Notes

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`