Namespaces
Variants

std::operator+(std::basic_string)

С ru.cppreference.net
 
 
 
std::basic_string
 
Определён в заголовке <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 начиная с 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 начиная с 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 начиная с 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) (начиная с 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 начиная с 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 начиная с 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) (начиная с 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) (начиная с C++11)
(constexpr начиная с 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) (начиная с C++11)
(constexpr начиная с 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) (начиная с C++11)
(constexpr начиная с 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) (начиная с C++11)
(constexpr начиная с 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) (начиная с 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) (начиная с C++11)
(constexpr начиная с 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) (начиная с C++11)
(constexpr начиная с 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) (начиная с C++11)
(constexpr начиная с 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) (начиная с C++26)

Возвращает строку, содержащую символы из lhs, за которыми следуют символы из rhs. Эквивалентно:

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); за исключением того, что оба lhs и rhs остаются в допустимом, но неопределённом состоянии. Если lhs и rhs имеют одинаковые аллокаторы, реализация может переместить данные из любого из них.
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);

Аллокатор, используемый для результата:

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

Другими словами:

  • Если один операнд является basic_string rvalue, используется его аллокатор.
  • В противном случае, select_on_container_copy_construction применяется к аллокатору lvalue basic_string операнда.

В каждом случае, левый операнд предпочтительнее, когда оба являются basic_string одной и той же категории значения.

Для (8-16), все rvalue basic_string операнды остаются в допустимом, но неопределённом состоянии.

(начиная с C++11)

Параметры

lhs - string , string view (since C++26) , character, or pointer to the first character in a null-terminated array
rhs - string , string view (since C++26) , character, or pointer to the first character in a null-terminated array

Возвращаемое значение

Строка, содержащая символы из lhs , за которыми следуют символы из rhs , с использованием аллокатора, определённого как указано выше (начиная с C++11) .

Примечания

operator+ следует использовать с большой осторожностью при работе с stateful аллокаторами (например, когда используется std::pmr::string ) (since C++17) . До принятия P1165R1 , аллокатор для результата определялся исторически сложившимся образом и мог варьироваться от перегрузки к перегрузке без видимой причины. Более того, для ( 1-5 ) , поведение распространения аллокатора различается между основными реализациями стандартной библиотеки и отличается от поведения, описанного в стандарте.

Поскольку аллокатор, используемый для результата operator+ , чувствителен к категории значения, operator+ не является ассоциативным относительно распространения аллокатора:

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

Для цепочки вызовов operator+ , аллокатор для конечного результата может быть контролируемым путем добавления rvalue basic_string с желаемым аллокатором в начало:

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

Для лучшего и переносимого контроля над аллокаторами следует использовать функции-члены, такие как append , insert , и operator+= , применяя их к строке-результату, сконструированной с желаемым аллокатором.

(since C++11)

Использование std:: type_identity_t в качестве параметра в перегрузках ( 4 ) , ( 7 ) , ( 12 ) и ( 16 ) гарантирует, что объект типа std:: basic_string < CharT, Traits, Allocator > всегда может быть конкатенирован с объектом типа T с неявным преобразованием в std:: basic_string_view < CharT, Traits > , и наоборот, в соответствии с правилами разрешения перегрузки .

Макрос тестирования возможностей Значение Стандарт Возможность
__cpp_lib_string_view 202403 (C++26) Конкатенация строк и string views, перегрузки ( 4 ) , ( 7 ) , ( 12 ) , ( 16 )
(начиная с C++26)

Пример

#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
}

Вывод:

Hello world!
Hello Waterworld!

Отчеты о дефектах

Следующие отчеты об изменениях поведения, влияющие на дефекты, были применены ретроактивно к ранее опубликованным стандартам C++.

DR Применяется к Поведение в опубликованной версии Корректное поведение
P1165R1 C++11 распространение аллокатора осуществляется бессистемно и непоследовательно сделано более последовательным

Смотрите также

добавляет символы в конец
(public member function)
добавляет символы в конец
(public member function)
вставляет символы
(public member function)