Namespaces
Variants
Views
Actions

Difference between revisions of "cpp/string/basic string/operator+"

From cppreference.com
< cpp‎ | string‎ | basic string
m (Use since= and until= params of {{dcl}} template.)
(+)
Line 109: Line 109:
  
 
12) {{c|std::move(lhs.append(1, rhs))}}
 
12) {{c|std::move(lhs.append(1, rhs))}}
 +
 +
=== Notes ===
 +
{{tt|operator+}} should be used with great caution when stateful allocators are involved (such as when {{lc|std::pmr::string}} is used). The allocator used for the result can vary from overload to overload, and the standard is occasionally contradictory. For many of the overloads, the allocator propagation behavior varies across major standard library implementations and differs from the behavior depicted in the standard.
 +
 +
For better and portable control over allocators, member functions like {{ltf|cpp/string/basic_string/append}}, {{ltf|cpp/string/basic_string/insert}}, and {{ltf|cpp/string/basic_string/operator+{{=}}}} should be used on a result string constructed with the desired allocator.
  
 
===Example===
 
===Example===

Revision as of 16:39, 31 October 2018

 
 
 
std::basic_string
Member functions
Element access
Iterators
Capacity
Modifiers
Search
Operations
Constants
Non-member functions
operator+
I/O
Comparison
(until C++20)(until C++20)(until C++20)(until C++20)(until C++20)(C++20)
Numeric conversions
(C++11)(C++11)(C++11)
(C++11)(C++11)
(C++11)(C++11)(C++11)
(C++11)
(C++11)
Literals
Helper classes
Deduction guides (C++17)

 
template< class CharT, class Traits, class Alloc >

    basic_string<CharT,Traits,Alloc>
        operator+( const basic_string<CharT,Traits,Alloc>& lhs,

                   const basic_string<CharT,Traits,Alloc>& rhs );
(1)
template< class CharT, class Traits, class Alloc >

    basic_string<CharT,Traits,Alloc>
        operator+( const CharT* lhs,

                   const basic_string<CharT,Traits,Alloc>& rhs );
(2)
template< class CharT, class Traits, class Alloc >

    basic_string<CharT,Traits,Alloc>
        operator+( CharT lhs,

                   const basic_string<CharT,Traits,Alloc>& rhs );
(3)
template< class CharT, class Traits, class Alloc >

    basic_string<CharT,Traits,Alloc>
        operator+( const basic_string<CharT,Traits,Alloc>& lhs,

                   const CharT* rhs );
(4)
template<class CharT, class Traits, class Alloc>

    basic_string<CharT,Traits,Alloc>
        operator+( const basic_string<CharT,Traits,Alloc>& lhs,

                   CharT rhs );
(5)
template< class CharT, class Traits, class Alloc >

    basic_string<CharT,Traits,Alloc>
        operator+( basic_string<CharT,Traits,Alloc>&& lhs,

                   const basic_string<CharT,Traits,Alloc>& rhs );
(6) (since C++11)
template< class CharT, class Traits, class Alloc >

    basic_string<CharT,Traits,Alloc>
        operator+( const basic_string<CharT,Traits,Alloc>& lhs,

                   basic_string<CharT,Traits,Alloc>&& rhs );
(7) (since C++11)
template< class CharT, class Traits, class Alloc >

    basic_string<CharT,Traits,Alloc>
        operator+( basic_string<CharT,Traits,Alloc>&& lhs,

                   basic_string<CharT,Traits,Alloc>&& rhs );
(8) (since C++11)
template< class CharT, class Traits, class Alloc >

    basic_string<CharT,Traits,Alloc>
        operator+(const CharT* lhs,

                  basic_string<CharT,Traits,Alloc>&& rhs );
(9) (since C++11)
template< class CharT, class Traits, class Alloc >

    basic_string<CharT,Traits,Alloc>
        operator+( CharT lhs,

                   basic_string<CharT,Traits,Alloc>&& rhs );
(10) (since C++11)
template< class CharT, class Traits, class Alloc >

    basic_string<CharT,Traits,Alloc>
        operator+( basic_string<CharT,Traits,Alloc>&& lhs,

                   const CharT* rhs );
(11) (since C++11)
template< class CharT, class Traits, class Alloc >

    basic_string<CharT,Traits,Alloc>
        operator+( basic_string<CharT,Traits,Alloc>&& lhs,

                   CharT rhs );
(12) (since C++11)

Returns a string containing characters from lhs followed by the characters from rhs.

Contents

Parameters

lhs - string, character, or pointer to the first character in a null-terminated array
rhs - string, character, or pointer to the first character in a null-terminated array

Return value

1) basic_string<CharT,Traits,Alloc>(lhs).append(rhs)

2) basic_string<CharT,Traits,Alloc>(lhs) + rhs

3) basic_string<CharT,Traits,Alloc>(1,lhs) + rhs

4) lhs + basic_string<CharT,Traits,Alloc>(rhs)

5) lhs + basic_string<CharT,Traits,Alloc>(1,rhs)

6) std::move(lhs.append(rhs))

7) std::move(rhs.insert(0, lhs))

8) std::move(lhs.append(rhs)) or std::move(rhs.insert(0, lhs))

9) std::move(rhs.insert(0, lhs))

10) std::move(rhs.insert(0, 1, lhs))

11) std::move(lhs.append(rhs))

12) std::move(lhs.append(1, rhs))

Notes

operator+ should be used with great caution when stateful allocators are involved (such as when std::pmr::string is used). The allocator used for the result can vary from overload to overload, and the standard is occasionally contradictory. For many of the overloads, the allocator propagation behavior varies across major standard library implementations and differs from the behavior depicted in the standard.

For better and portable control over allocators, member functions like append(), insert(), and operator+=() should be used on a result string constructed with the desired allocator.

Example

#include <iostream>
#include <string>
 
int main()
{
    std::string s1 = "Hello";
    std::string s2 = "world";
    std::cout << s1 + ' ' + s2 + "!\n";
}

Output:

Hello world!

See also

appends characters to the end
(public member function) [edit]
appends characters to the end
(public member function) [edit]
inserts characters
(public member function) [edit]