std::operator+(std::basic_string)

Défini dans l'en-tête `<string>`
template< class CharT, class Traits, class Alloc > std::basic_string<CharT,Traits,Alloc> operator+( const std::basic_string<CharT,Traits,Alloc>& lhs, const std::basic_string<CharT,Traits,Alloc>& rhs );	(1)	(constexpr depuis C++20)
template< class CharT, class Traits, class Alloc > std::basic_string<CharT,Traits,Alloc> operator+( const std::basic_string<CharT,Traits,Alloc>& lhs, const CharT* rhs );	(2)	(constexpr depuis C++20)
template< class CharT, class Traits, class Alloc > std::basic_string<CharT,Traits,Alloc> operator+( const std::basic_string<CharT,Traits,Alloc>& lhs, CharT rhs );	(3)	(constexpr depuis C++20)
template< class CharT, class Traits, class Alloc > constexpr std::basic_string<CharT,Traits,Alloc> operator+( const std::basic_string<CharT,Traits,Alloc>& lhs, std::type_identity_t<std::basic_string_view<CharT,Traits>> rhs );	(4)	(depuis C++26)
template< class CharT, class Traits, class Alloc > std::basic_string<CharT,Traits,Alloc> operator+( const CharT* lhs, const std::basic_string<CharT,Traits,Alloc>& rhs );	(5)	(constexpr depuis C++20)
template< class CharT, class Traits, class Alloc > std::basic_string<CharT,Traits,Alloc> operator+( CharT lhs, const std::basic_string<CharT,Traits,Alloc>& rhs );	(6)	(constexpr depuis C++20)
template< class CharT, class Traits, class Alloc > constexpr std::basic_string<CharT,Traits,Alloc> operator+( std::type_identity_t<std::basic_string_view<CharT,Traits>> lhs, const std::basic_string<CharT,Traits,Alloc>& rhs );	(7)	(depuis C++26)
template< class CharT, class Traits, class Alloc > std::basic_string<CharT,Traits,Alloc> operator+( std::basic_string<CharT,Traits,Alloc>&& lhs, std::basic_string<CharT,Traits,Alloc>&& rhs );	(8)	(depuis C++11) (constexpr depuis C++20)
template< class CharT, class Traits, class Alloc > std::basic_string<CharT,Traits,Alloc> operator+( std::basic_string<CharT,Traits,Alloc>&& lhs, const std::basic_string<CharT,Traits,Alloc>& rhs );	(9)	(depuis C++11) (constexpr depuis C++20)
template< class CharT, class Traits, class Alloc > std::basic_string<CharT,Traits,Alloc> operator+( std::basic_string<CharT,Traits,Alloc>&& lhs, const CharT* rhs );	(10)	(depuis C++11) (constexpr depuis C++20)
template< class CharT, class Traits, class Alloc > std::basic_string<CharT,Traits,Alloc> operator+( std::basic_string<CharT,Traits,Alloc>&& lhs, CharT rhs );	(11)	(depuis C++11) (constexpr depuis C++20)
template< class CharT, class Traits, class Alloc > constexpr std::basic_string<CharT,Traits,Alloc> operator+( std::basic_string<CharT,Traits,Alloc>&& lhs, std::type_identity_t<std::basic_string_view<CharT,Traits>> rhs );	(12)	(depuis C++26)
template< class CharT, class Traits, class Alloc > std::basic_string<CharT,Traits,Alloc> operator+( const std::basic_string<CharT,Traits,Alloc>& lhs, std::basic_string<CharT,Traits,Alloc>&& rhs );	(13)	(depuis C++11) (constexpr depuis C++20)
template< class CharT, class Traits, class Alloc > std::basic_string<CharT,Traits,Alloc> operator+( const CharT* lhs, std::basic_string<CharT,Traits,Alloc>&& rhs );	(14)	(depuis C++11) (constexpr depuis C++20)
template< class CharT, class Traits, class Alloc > std::basic_string<CharT,Traits,Alloc> operator+( CharT lhs, std::basic_string<CharT,Traits,Alloc>&& rhs );	(15)	(depuis C++11) (constexpr depuis C++20)
template< class CharT, class Traits, class Alloc > constexpr std::basic_string<CharT,Traits,Alloc> operator+( std::type_identity_t<std::basic_string_view<CharT,Traits>> lhs, std::basic_string<CharT,Traits,Alloc>&& rhs );	(16)	(depuis C++26)

Renvoie une chaîne contenant les caractères de lhs suivis des caractères de rhs. Équivalent à :

1,2) std::basic_string<CharT, Traits, Allocator> r = lhs; r.append(rhs); return r;

3) std::basic_string<CharT, Traits, Allocator> r = lhs; r.push_back(rhs); return r;

4) std::basic_string<CharT, Traits, Allocator> r = lhs; r.append(rhs); return r;

5) std::basic_string<CharT, Traits, Allocator> r = rhs; r.insert(0, lhs); return r;

6) std::basic_string<CharT, Traits, Allocator> r = rhs; r.insert(r.begin(), lhs); return r;

7) std::basic_string<CharT, Traits, Allocator> r = rhs; r.insert(0, lhs); return r;

8) lhs.append(rhs); return std::move(lhs); sauf que lhs et rhs sont tous deux laissés dans un état valide mais non spécifié. Si lhs et rhs ont des allocateurs égaux, l'implémentation peut déplacer l'un ou l'autre.

9,10) lhs.append(rhs); return std::move(lhs);

11) lhs.push_back(rhs); return std::move(lhs);

12) lhs.append(rhs); return std::move(lhs);

13,14) rhs.insert(0, lhs); return std::move(rhs);

15) rhs.insert(rhs.begin(), lhs); return std::move(rhs);

16) rhs.insert(0, lhs); return std::move(rhs);

L'allocateur utilisé pour le résultat est :

1-4) std::allocator_traits<Alloc>::select_on_container_copy_construction(lhs.get_allocator())

5-7) std::allocator_traits<Alloc>::select_on_container_copy_construction(rhs.get_allocator())

8-12) lhs.get_allocator()

13-16) rhs.get_allocator()

Autrement dit :

Si un opérande est une basic_string rvalue, son allocateur est utilisé.
Sinon, select_on_container_copy_construction est utilisé sur l'allocateur de l'opérande de basic_string lvalue.

Dans chaque cas, l'opérande gauche est préféré lorsque les deux sont des basic_strings de la même catégorie de valeur.

Pour (8-16), tous les opérandes basic_string rvalue sont laissés dans un état valide mais non spécifié.

(depuis C++11)

Paramètres

lhs	-	string , string view (depuis C++26) , caractère, ou pointeur vers le premier caractère d'un tableau terminé par null
rhs	-	string , string view (depuis C++26) , caractère, ou pointeur vers le premier caractère d'un tableau terminé par null

Valeur de retour

Une chaîne contenant les caractères de lhs suivis des caractères de rhs , en utilisant l'allocateur déterminé comme ci-dessus (depuis C++11) .

Notes

operator+ doit être utilisé avec une grande prudence lorsque des allocateurs avec état sont impliqués (comme lorsque std::pmr::string est utilisé) (depuis C++17) . Avant P1165R1 , l'allocateur utilisé pour le résultat était déterminé par des accidents historiques et pouvait varier d'une surcharge à l'autre sans raison apparente. De plus, pour ( 1-5 ) , le comportement de propagation des allocateurs varie entre les principales implémentations de bibliothèques standard et diffère du comportement décrit dans la norme.

Étant donné que l'allocateur utilisé par le résultat de operator+ est sensible à la catégorie de valeur, operator+ n'est pas associatif en ce qui concerne la propagation des allocateurs :

using my_string = std::basic_string<char, std::char_traits<char>, my_allocator<char>>;
my_string cat();
const my_string& dog();
my_string meow = /* ... */, woof = /* ... */;
meow + cat() + /* ... */; // utilise select_on_container_copy_construction sur l'allocateur de meow
woof + dog() + /* ... */; // utilise l'allocateur de la valeur de retour de dog() à la place
meow + woof + meow; // utilise select_on_container_copy_construction sur l'allocateur de meow
meow + (woof + meow); // utilise SOCCC sur l'allocateur de woof à la place

Pour une chaîne d'appels de operator+ , l'allocateur utilisé pour le résultat final peut être contrôlé en préfixant une valeur rvalue basic_string avec l'allocateur souhaité :

// utilise my_favorite_allocator pour le résultat final
my_string(my_favorite_allocator) + meow + woof + cat() + dog();

Pour un contrôle meilleur et portable des allocateurs, les fonctions membres comme append , insert , et operator+= doivent être utilisées sur une chaîne résultat construite avec l'allocateur souhaité.

(depuis C++11)

L'utilisation de std:: type_identity_t comme paramètre dans les surcharges ( 4 ) , ( 7 ) , ( 12 ) , et ( 16 ) garantit qu'un objet de type std:: basic_string < CharT, Traits, Allocator > peut toujours être concaténé à un objet de type T avec une conversion implicite vers std:: basic_string_view < CharT, Traits > , et vice versa, conformément aux règles de résolution de surcharge .

Macro de test de fonctionnalité	Valeur	Std	Fonctionnalité
`__cpp_lib_string_view`	`202403`	(C++26)	Concaténation de chaînes et de vues de chaînes, surcharges ( 4 ) , ( 7 ) , ( 12 ) , ( 16 )

(depuis C++26)

Exemple

Exécuter ce code

#include <iostream>
#include <string>
#include <string_view>
int main()
{
    std::string s1 = "Hello";
    std::string s2 = "world";
    const char* end = "!\n";
    std::cout << s1 + ' ' + s2 + end;
    std::string_view water{" Water"};
    #if __cpp_lib_string_view >= 202403
    std::cout << s1 + water + s2 << end; // overload (4), then (1)
    #else
    std::cout << s1 + std::string(water) + s2 << end; // OK, but less efficient
    #endif
}

Sortie :

Hello world!
Hello Waterworld!

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
P1165R1	C++11	la propagation de l'allocateur est erratique et incohérente	rendue plus cohérente

Voir aussi

operator+=	ajoute des caractères à la fin (fonction membre publique)
append	ajoute des caractères à la fin (fonction membre publique)
insert	insère des caractères (fonction membre publique)

Support du compilateur
Autonome et hébergé
Langage
Bibliothèque standard
En-têtes de la bibliothèque standard
Exigences nommées
Macros de test des fonctionnalités (C++20)
Bibliothèque de support du langage
Bibliothèque de concepts (C++20)
Bibliothèque de diagnostics
Bibliothèque de gestion de la mémoire
Bibliothèque de métaprogrammation (C++11)
Bibliothèque d'utilitaires généraux
Bibliothèque de conteneurs
Bibliothèque d'itérateurs
Bibliothèque de plages (C++20)
Bibliothèque d'algorithmes
Bibliothèque de chaînes de caractères
Bibliothèque de traitement de texte
Bibliothèque numérique
Bibliothèque de dates et heures
Bibliothèque d'entrée/sortie
Bibliothèque de système de fichiers (C++17)
Bibliothèque de support de la concurrence (C++11)
Bibliothèque de contrôle d'exécution (C++26)
Spécifications techniques
Index des symboles
Bibliothèques externes

fr.cppreference.net

Namespaces

Variants