Конкатенация строки с копией()

Question

Я новичок в C++, и мне интересно, есть ли способ объединить строки из vector< string> в одну строку, используя copy(). Я знаю, что могу использовать accumulate(), но интересно, что случилось «под капотом» с этим кодом:

string concat_v (const vector<string>& v) { 
    string s; 
    copy(v.begin(), v.end(), back_inserter(s)); 
    return s; 
} 

Или с:

s.insert(s.end(), v.begin(), v.end()); 

Answer 1

Проблема с примерами кода является то, что вы не можете скопируйте string в то, что ожидает char. Это та же проблема, как:

string s = "Hello"; 
char ch = s;   // ??? 

std::accumulate функция делает именно то, что вы просите, я не знаю, почему вы все еще интересно, если есть способ :) Способ использовать это:

string s; 
s = std::accumulate(v.begin(), v.end(), s); 

, который вызывает operator+, чтобы сделать накопление. Существует также версия накопления, которая вызывает пользовательскую функцию, которую вы предоставляете.

Answer 2

Если вы ищете один вкладыш, я бы использовал accumulate. Я не думаю, что есть способ с двумя упомянутыми вами.

string concat_v (const vector<string>& v) { 
    string s; 
    s = accumulate(v.begin(), v.end(), string()); 
    return s; 
}  

Answer 3

Если вы действительно хотите, чтобы сделать работу с std::copy вместо std::accumulate, вы могли бы сделать это с небольшим количеством посредников, таких как std::stringstream:

string concat_v (const vector<string>& v) { 
    stringstream s; 
    copy(v.begin(), v.end(), ostream_iterator<string>(s)); 
    return s.str(); 
} 

Для этой конкретной цели, где все входы одного типа и поддерживают оператор сложения (и он делает то, что вы хотите), accumulate кажется ясным выбором. Использование stringstream может быть предпочтительным, когда/если вы хотите объединить строку, даже если (например) добавление элементов может привести к чему-то совершенно другому (например, вы хотите, чтобы массив int, содержащий {1, 2, 3}, вышел как 123 или 1 2 3, а не 6).

Answer 4

Идет с std :: accumulate приносит заметное преимущество с точки зрения производительности.

В аккумулирует, мы имеем

while (first!=last) { 
    init = init + *first; 
    ++first; 
    } 

«инициализации» является результирующей из эксплуатации + вызовов и накапливать сцепленную строку. Это хорошо, поскольку он не выделяет временные ряды для каждого промежуточного результата и не копирует его. Конечно, для изменения размера строки вы можете создавать копии - но это другое дело.

Дифференциал производительности является нетривиальным.