Namespaces
Variants

std:: basic_string_view

From cppreference.net
C++
Strings library
Classes
basic_string_view
(C++17)
std::basic_string_view
Défini dans l'en-tête <string_view>
template <

class CharT,
class Traits = std:: char_traits < CharT >

> class basic_string_view ;
(depuis C++17)

Le modèle de classe basic_string_view décrit un objet qui peut faire référence à une séquence contiguë constante de CharT avec le premier élément de la séquence à la position zéro.

Pour un basic_string_view str , les pointeurs, itérateurs et références aux éléments de str sont invalidés lorsqu'une opération invalide un pointeur dans la plage [ str. data ( ) , str. data ( ) + str. size ( ) ) .

Chaque spécialisation de std::basic_string_view est un type TriviallyCopyable .

(depuis C++23)

Plusieurs typedefs pour les types de caractères courants sont fournis :

Défini dans l'en-tête <string_view>
Type Définition
std::string_view (C++17) std :: basic_string_view < char >
std::wstring_view (C++17) std :: basic_string_view < wchar_t >
std::u8string_view (C++20) std :: basic_string_view < char8_t >
std::u16string_view (C++17) std :: basic_string_view < char16_t >
std::u32string_view (C++17) std :: basic_string_view < char32_t >

Table des matières

Paramètres du modèle

CharT - type de caractère
Traits - CharTraits classe spécifiant les opérations sur le type de caractère. Comme pour std::basic_string , Traits::char_type doit désigner le même type que CharT ou le programme est mal formé.

Types imbriqués

Type Définition
traits_type Traits
value_type CharT
pointer CharT *
const_pointer const CharT *
reference CharT &
const_reference const CharT &
const_iterator itérateur constant défini par l'implémentation LegacyRandomAccessIterator ,
et LegacyContiguousIterator (jusqu'en C++20)
ConstexprIterator , et contiguous_iterator (depuis C++20)

dont le value_type est CharT

iterator const_iterator
const_reverse_iterator std:: reverse_iterator < const_iterator >
reverse_iterator const_reverse_iterator
size_type std::size_t
difference_type std::ptrdiff_t

Note : iterator et const_iterator sont le même type car les string views sont des vues sur des séquences de caractères constantes.

Toutes les exigences relatives aux types d'itérateurs d'un Container s'appliquent également aux types iterator et const_iterator de basic_string_view .

Membres de données

Membre Description
const_pointer data_ un pointeur vers la séquence sous-jacente
( objet membre d'exposition uniquement* )
size_type size_ le nombre de caractères
( objet membre d'exposition uniquement* )

Fonctions membres

Constructeurs et assignation
construit un basic_string_view
(fonction membre publique)
assigne une vue
(fonction membre publique)
Itérateurs
retourne un itérateur vers le début
(fonction membre publique)
retourne un itérateur vers la fin
(fonction membre publique)
retourne un itérateur inverse vers le début
(fonction membre publique)
retourne un itérateur inverse vers la fin
(fonction membre publique)
Accès aux éléments
accède au caractère spécifié
(fonction membre publique)
accède au caractère spécifié avec vérification des limites
(fonction membre publique)
accède au premier caractère
(fonction membre publique)
accède au dernier caractère
(fonction membre publique)
renvoie un pointeur vers le premier caractère d'une vue
(fonction membre publique)
Capacité
renvoie le nombre de caractères
(fonction membre publique)
retourne le nombre maximum de caractères
(fonction membre publique)
vérifie si la vue est vide
(fonction membre publique)
Modificateurs
réduit la vue en déplaçant son début vers l'avant
(fonction membre publique)
réduit la vue en déplaçant sa fin vers l'arrière
(fonction membre publique)
échange le contenu
(fonction membre publique)
Opérations
copie des caractères
(fonction membre publique)
retourne une sous-chaîne
(fonction membre publique)
compare deux vues
(fonction membre publique)
(C++20)
vérifie si la vue de chaîne commence par le préfixe donné
(fonction membre publique)
(C++20)
vérifie si la vue de chaîne se termine par le suffixe donné
(fonction membre publique)
(C++23)
vérifie si la vue de chaîne contient la sous-chaîne ou le caractère donné
(fonction membre publique)
rechercher des caractères dans la vue
(fonction membre publique)
trouver la dernière occurrence d'une sous-chaîne
(fonction membre publique)
trouver la première occurrence de caractères
(fonction membre publique)
trouver la dernière occurrence de caractères
(fonction membre publique)
trouver la première absence de caractères
(fonction membre publique)
trouver la dernière absence de caractères
(fonction membre publique)

Constantes

[static]
valeur spéciale. La signification exacte dépend du contexte
(constante de membre public static)

Fonctions non membres

(C++17) (supprimé en C++20) (supprimé en C++20) (supprimé en C++20) (supprimé en C++20) (supprimé en C++20) (C++20)
compare lexicographiquement deux vues de chaîne
(modèle de fonction)
Entrée/sortie
(C++17)
effectue une sortie de flux sur les vues de chaîne
(modèle de fonction)

Littéraux

Défini dans l'espace de noms en ligne std::literals::string_view_literals
(C++17)
crée une vue de chaîne à partir d'un littéral de tableau de caractères
(fonction)

Classes d'assistance

(C++17) (C++17) (C++20) (C++17) (C++17)
prise en charge du hachage pour les vues de chaînes
(spécialisation de modèle de classe)

Modèles d'assistance

template < class CharT, class Traits >

inline constexpr bool

ranges:: enable_borrowed_range < std :: basic_string_view < CharT, Traits >> = true ;
(depuis C++20)

Cette spécialisation de ranges::enable_borrowed_range permet à basic_string_view de satisfaire borrowed_range .

template < class CharT, class Traits >

inline constexpr bool

ranges:: enable_view < std :: basic_string_view < CharT, Traits >> = true ;
(depuis C++20)

Cette spécialisation de ranges::enable_view permet à basic_string_view de satisfaire view .

Guides de déduction

(depuis C++20)

Notes

Il est de la responsabilité du programmeur de s'assurer que std::string_view ne survive pas au tableau de caractères pointé : 

std::string_view good{"a string literal"};
    // Cas "bon" : `good` pointe vers un tableau statique.
    // Les littéraux de chaîne résident dans un stockage de données persistant.
std::string_view bad{"a temporary string"s};
    // Cas "mauvais" : `bad` contient un pointeur pendulaire car le temporaire std::string,
    // créé par std::operator""s, sera détruit à la fin de l'instruction.

Les spécialisations de std::basic_string_view sont déjà des types trivialement copiables dans toutes les implémentations existantes, même avant l'exigence formelle introduite en C++23.

Macro de test de fonctionnalité Valeur Std Fonctionnalité
__cpp_lib_string_view 201606L (C++17) std::string_view
201803L (C++20) ConstexprIterator
__cpp_lib_string_contains 202011L (C++23) contains

Exemple

Exécuter ce code 
#include <iostream>
#include <string_view>
int main()
{
    #define A "▀"
    #define B "▄"
    #define C "─"
    constexpr std::string_view blocks[]{A B C, B A C, A C B, B C A};
    for (int y{}, p{}; y != 8; ++y, p = ((p + 1) % 4))
    {
        for (char x{}; x != 29; ++x)
            std::cout << blocks[p];
        std::cout << '\n';
    }
}

Sortie : 

▀▄─▀▄─▀▄─▀▄─▀▄─▀▄─▀▄─▀▄─▀▄─▀▄─▀▄─▀▄─▀▄─▀▄─▀▄─▀▄─▀▄─▀▄─▀▄─▀▄─▀▄─▀▄─▀▄─▀▄─▀▄─▀▄─▀▄─▀▄─▀▄─
▄▀─▄▀─▄▀─▄▀─▄▀─▄▀─▄▀─▄▀─▄▀─▄▀─▄▀─▄▀─▄▀─▄▀─▄▀─▄▀─▄▀─▄▀─▄▀─▄▀─▄▀─▄▀─▄▀─▄▀─▄▀─▄▀─▄▀─▄▀─▄▀─
▀─▄▀─▄▀─▄▀─▄▀─▄▀─▄▀─▄▀─▄▀─▄▀─▄▀─▄▀─▄▀─▄▀─▄▀─▄▀─▄▀─▄▀─▄▀─▄▀─▄▀─▄▀─▄▀─▄▀─▄▀─▄▀─▄▀─▄▀─▄▀─▄
▄─▀▄─▀▄─▀▄─▀▄─▀▄─▀▄─▀▄─▀▄─▀▄─▀▄─▀▄─▀▄─▀▄─▀▄─▀▄─▀▄─▀▄─▀▄─▀▄─▀▄─▀▄─▀▄─▀▄─▀▄─▀▄─▀▄─▀▄─▀▄─▀
▀▄─▀▄─▀▄─▀▄─▀▄─▀▄─▀▄─▀▄─▀▄─▀▄─▀▄─▀▄─▀▄─▀▄─▀▄─▀▄─▀▄─▀▄─▀▄─▀▄─▀▄─▀▄─▀▄─▀▄─▀▄─▀▄─▀▄─▀▄─▀▄─
▄▀─▄▀─▄▀─▄▀─▄▀─▄▀─▄▀─▄▀─▄▀─▄▀─▄▀─▄▀─▄▀─▄▀─▄▀─▄▀─▄▀─▄▀─▄▀─▄▀─▄▀─▄▀─▄▀─▄▀─▄▀─▄▀─▄▀─▄▀─▄▀─
▀─▄▀─▄▀─▄▀─▄▀─▄▀─▄▀─▄▀─▄▀─▄▀─▄▀─▄▀─▄▀─▄▀─▄▀─▄▀─▄▀─▄▀─▄▀─▄▀─▄▀─▄▀─▄▀─▄▀─▄▀─▄▀─▄▀─▄▀─▄▀─▄
▄─▀▄─▀▄─▀▄─▀▄─▀▄─▀▄─▀▄─▀▄─▀▄─▀▄─▀▄─▀▄─▀▄─▀▄─▀▄─▀▄─▀▄─▀▄─▀▄─▀▄─▀▄─▀▄─▀▄─▀▄─▀▄─▀▄─▀▄─▀▄─▀

Rapports de défauts

Les rapports de défauts modifiant le comportement suivants ont été appliqués rétroactivement aux normes C++ précédemment publiées.

DR Appliqué à Comportement tel que publié Comportement correct
LWG 3203 C++17 seuls les pointeurs, itérateurs et références
retournés par les fonctions membres de
basic_string_view peuvent être invalidés 		tous les pointeurs, itérateurs et références
vers les éléments de basic_string_view
peuvent être invalidés

Voir aussi

stocke et manipule des séquences de caractères
(modèle de classe)
concatène deux chaînes, une chaîne et un char , ou une chaîne et un string_view
(modèle de fonction)
(C++20)
une vue non propriétaire sur une séquence contiguë d'objets
(modèle de classe)
(C++11)
référence un tableau temporaire créé lors de l'initialisation de liste
(modèle de classe)