Namespaces
Variants

std::basic_string<CharT,Traits,Allocator>:: operator+=

From cppreference.net
C++
Strings library
std::basic_string
basic_string & operator + = ( const basic_string & str ) ;
(1) (constexpr depuis C++20)
basic_string & operator + = ( CharT ch ) ;
(2) (constexpr depuis C++20)
basic_string & operator + = ( const CharT * s ) ;
(3) (constexpr depuis C++20)
basic_string & operator + = ( std:: initializer_list < CharT > ilist ) ;
(4) (depuis C++11)
(constexpr depuis C++20)
template < class StringViewLike >
basic_string & operator + = ( const StringViewLike & t ) ;
(5) (depuis C++17)
(constexpr depuis C++20)

Ajoute des caractères supplémentaires à la chaîne.

1) Ajoute la chaîne str .
2) Ajoute le caractère ch .
3) Ajoute la chaîne de caractères terminée par un caractère nul pointée par s .
4) Ajoute les caractères dans la std::initializer_list ilist .
5) Convertit implicitement t en une vue de chaîne sv comme si par std:: basic_string_view < CharT, Traits > sv = t ; , puis ajoute les caractères de la vue de chaîne sv comme si par append ( sv ) .
Cette surcharge participe à la résolution de surcharge seulement si std:: is_convertible_v < const StringViewLike & ,
std:: basic_string_view < CharT, Traits >> est true et std:: is_convertible_v < const StringViewLike & , const CharT * > est false .

Table des matières

Paramètres

str - chaîne à ajouter
ch - valeur de caractère à ajouter
s - pointeur vers une chaîne de caractères terminée par un caractère nul à ajouter
ilist - std::initializer_list avec les caractères à ajouter
t - objet (convertible en std::basic_string_view ) avec les caractères à ajouter

Valeur de retour

* this

Complexité

Il n'y a pas de garanties de complexité standard, les implémentations typiques se comportent de manière similaire à std::vector::insert() .

Exceptions

Si l'opération devait entraîner le dépassement de size() par rapport à max_size() , lève std::length_error .

Si une exception est levée pour quelque raison que ce soit, cette fonction n'a aucun effet ( garantie forte de sûreté face aux exceptions ).

Notes

Surcharge ( 2 ) peut accepter tous les types implicitement convertibles en CharT . Pour std::string , où CharT est char , l'ensemble des types acceptables inclut tous les types arithmétiques. Cela peut avoir des effets non intentionnels.

Exemple

Exécuter ce code 
#include <iomanip>
#include <iostream>
#include <string>
int main()
{
    std::string str;
    // réserver un espace de stockage suffisant pour éviter la réallocation de mémoire
    str.reserve(50);
    std::cout << std::quoted(str) << '\n'; // chaîne vide
    str += "This";
    std::cout << std::quoted(str) << '\n';
    str += std::string(" is ");
    std::cout << std::quoted(str) << '\n';
    str += 'a';
    std::cout << std::quoted(str) << '\n';
    str += {' ', 's', 't', 'r', 'i', 'n', 'g', '.'};
    std::cout << std::quoted(str) << '\n';
    str += 69.96; // Équivalent à str += static_cast<char>(69.96);
                  // 'E' (code ASCII 69) est ajouté par la surcharge (2),
                  // ce qui pourrait ne pas être l'intention.
    // Pour ajouter une valeur numérique, considérez std::to_string() :
    str += std::to_string(1729);
    std::cout << std::quoted(str) << '\n';
}

Sortie : 

""
"This"
"This is "
"This is a"
"This is a string."
"This is a string.E1729"

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 publié Comportement corrigé
LWG 847 C++98 il n'y avait aucune garantie de sécurité des exceptions garantie de sécurité forte des exceptions ajoutée
LWG 2946 C++17 la surcharge ( 5 ) provoquait une ambiguïté dans certains cas évitée en la transformant en template

Voir aussi

ajoute des caractères à la fin
(fonction membre publique)