Namespaces
Variants

    std::operator+(std::basic_string)

    Von de.cppreference.net
     
    C++
     
    Zeichenkettenbibliothek
     
    std::basic_string
     
    Definiert im Header <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 seit 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 seit 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 seit 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) (seit 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 seit 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 seit 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) (seit 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) (seit C++11)
    (constexpr seit 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) (seit C++11)
    (constexpr seit 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) (seit C++11)
    (constexpr seit 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) (seit C++11)
    (constexpr seit 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) (seit 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) (seit C++11)
    (constexpr seit 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) (seit C++11)
    (constexpr seit 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) (seit C++11)
    (constexpr seit 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) (seit C++26)

    Gibt eine Zeichenkette zurück, die Zeichen aus lhs gefolgt von den Zeichen aus rhs enthält. Äquivalent zu:

    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); außer dass sowohl lhs als auch rhs in einem gültigen, aber nicht spezifizierten Zustand belassen werden. Wenn lhs und rhs gleiche Allokatoren haben, kann die Implementierung von einem von beiden verschieben.
    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);

    Der für das Ergebnis verwendete Allokator ist:

    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()

    Mit anderen Worten:

    • Wenn ein Operand ein basic_string rvalue ist, wird sein Allokator verwendet.
    • Andernfalls wird select_on_container_copy_construction auf den Allokator des lvalue basic_string-Operanden angewendet.

    In jedem Fall wird der linke Operand bevorzugt, wenn beide basic_strings derselben Wertkategorie sind.

    Für (8-16) werden alle rvalue basic_string-Operanden in einem gültigen, aber nicht spezifizierten Zustand belassen.

    		(seit C++11)

    Parameter

    lhs - string , string view (since C++26) , Zeichen oder Zeiger auf das erste Zeichen in einer nullterminierten Zeichenfolge
    rhs - string , string view (since C++26) , Zeichen oder Zeiger auf das erste Zeichen in einer nullterminierten Zeichenfolge

    Rückgabewert

    Ein String, der die Zeichen aus lhs gefolgt von den Zeichen aus rhs , unter Verwendung des wie oben bestimmten Allokators (since C++11) , enthält.

    Hinweise

    operator+ sollte mit großer Vorsicht verwendet werden, wenn zustandsbehaftete Allokatoren beteiligt sind (wie z.B. wenn std::pmr::string verwendet wird) (seit C++17) . Vor P1165R1 wurde der für das Ergebnis verwendete Allokator durch historische Zufälligkeiten bestimmt und konnte von Überladung zu Überladung ohne ersichtlichen Grund variieren. Darüber hinaus variiert für ( 1-5 ) das Allokator-Propagationsverhalten zwischen den wichtigsten Standardbibliothek-Implementierungen und unterscheidet sich vom im Standard dargestellten Verhalten.

    Da der vom Ergebnis von operator+ verwendete Allokator empfindlich auf den Wertkategorie reagiert, ist operator+ in Bezug auf die Allokator-Propagation nicht assoziativ: 

    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() + /* ... */; // uses select_on_container_copy_construction on meow's allocator
woof + dog() + /* ... */; // uses allocator of dog()'s return value instead
meow + woof + meow; // uses select_on_container_copy_construction on meow's allocator
meow + (woof + meow); // uses SOCCC on woof's allocator instead

    Für eine Kette von operator+ -Aufrufen kann der für das Endergebnis verwendete Allokator gesteuert werden, indem ein Rvalue- basic_string mit dem gewünschten Allokator vorangestellt wird: 

    // use my_favorite_allocator for the final result
my_string(my_favorite_allocator) + meow + woof + cat() + dog();

    Für eine bessere und portable Steuerung von Allokatoren sollten Member-Funktionen wie append , insert und operator+= auf einem Ergebnis-String verwendet werden, der mit dem gewünschten Allokator konstruiert wurde.

    		(seit C++11)

    Die Verwendung von std:: type_identity_t als Parameter in Überladungen ( 4 ) , ( 7 ) , ( 12 ) und ( 16 ) stellt sicher, dass ein Objekt vom Typ std:: basic_string < CharT, Traits, Allocator > stets mit einem Objekt eines Typs T mit impliziter Konvertierung zu std:: basic_string_view < CharT, Traits > verkettet werden kann, und umgekehrt, gemäß den Überladungsauflösungsregeln .

    Feature-Test Makro Wert Std Feature
    __cpp_lib_string_view 202403 (C++26) Verkettung von Strings und String-Views, Überladungen ( 4 ) , ( 7 ) , ( 12 ) , ( 16 )
    		(seit C++26)

    Beispiel

    Diesen Code ausführen 
    #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; // Überladung (4), dann (1)
    #else
    std::cout << s1 + std::string(water) + s2 << end; // OK, aber weniger effizient
    #endif
}

    Ausgabe: 

    Hello world!
Hello Waterworld!

    Fehlerberichte

    Die folgenden verhaltensändernden Fehlerberichte wurden rückwirkend auf zuvor veröffentlichte C++-Standards angewendet.

    DR Angewendet auf Verhalten wie veröffentlicht Korrektes Verhalten
    P1165R1 C++11 Allokator-Propagation ist planlos und inkonsistent konsistenter gestaltet

    Siehe auch

    		Fügt Zeichen am Ende an
    (öffentliche Elementfunktion)
    		Fügt Zeichen am Ende an
    (öffentliche Elementfunktion)
    		Fügt Zeichen ein
    (öffentliche Elementfunktion)