std::basic_string

template<
    class CharT,
    class Traits = std::char_traits<CharT>,
    class Allocator = std::allocator<CharT>
> class basic_string;

namespace pmr {
template<
    class CharT,
    class Traits = std::char_traits<CharT>
> using basic_string =
    std::basic_string<CharT, Traits, std::pmr::polymorphic_allocator<CharT>>;
}

Le modèle de classe basic_string stocke et manipule des séquences d'objets de type caractère, qui sont des objets non-tableaux de type TrivialType et StandardLayoutType. La classe ne dépend ni du type de caractère ni de la nature des opérations sur ce type. Les définitions des opérations sont fournies via le paramètre de modèle Traits - une spécialisation de std::char_traits ou une classe de traits compatible.

Les éléments d'un basic_string sont stockés de manière contiguë, c'est-à-dire que pour un basic_string s, &*(s.begin() + n) == &*s.begin() + n pour tout n dans [0, s.size()), et *(s.begin() + s.size()) a la valeur CharT() (un terminateur nul)(depuis C++11); ou, de manière équivalente, un pointeur vers s[0] peut être passé à des fonctions qui attendent un pointeur vers le premier élément de un tableau(jusqu'à C++11)un tableau terminé par un nul(depuis C++11) de CharT.

std::basic_string satisfait aux exigences de AllocatorAwareContainer (sauf que les versions personnalisées construct/destroy ne sont pas utilisées pour la construction/destruction d'éléments), SequenceContainer et ContiguousContainer(depuis C++17).

Si l'un de Traits::char_type et Allocator::char_type est différent de CharT, le programme est mal formé.

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

Paramètres du modèle

Types imbriqués

Membres de données

Fonctions membres

Fonctions non membres

Littéraux

Classes d'assistance

Guides de déduction (depuis C++17)

Invalidation des itérateurs

Les références, pointeurs et itérateurs faisant référence aux éléments d'un basic_string peuvent être invalidés par toute fonction de la bibliothèque standard prenant une référence à un basic_string non constant comme argument, telles que std::getline , std::swap , ou operator>> , et par l'appel de fonctions membres non constantes, à l'exception de operator[] , at , data , front , back , begin , rbegin , end , et rend .

Notes

Bien qu'il soit requis qu'un construct ou destroy personnalisé soit utilisé lors de la construction ou de la destruction des éléments de std::basic_string jusqu'au C++23, toutes les implémentations n'ont utilisé que le mécanisme par défaut. Cette exigence est corrigée par P1072R10 pour correspondre à la pratique existante.

Exemple

#include <iostream>
#include <string>
int main()
{
    using namespace std::literals;
    // Création d'une chaîne à partir de const char*
    std::string str1 = "hello";
    // Création d'une chaîne en utilisant un littéral de chaîne
    auto str2 = "world"s;
    // Concaténation de chaînes
    std::string str3 = str1 + " " + str2;
    // Affichage du résultat
    std::cout << str3 << '\n';
    std::string::size_type pos = str3.find(" ");
    str1 = str3.substr(pos + 1); // la partie après l'espace
    str2 = str3.substr(0, pos);  // la partie jusqu'à l'espace
    std::cout << str1 << ' ' << str2 << '\n';
    // Accès à un élément en utilisant l'opérateur d'indice []
    std::cout << str1[0] << '\n';
    str1[0] = 'W';
    std::cout << str1 << '\n';
}

hello world
world hello
w
World

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.

1. ↑ Le cas Traits::char_type est corrigé dans P1148R0 .

Voir aussi

Liens externes