Efficient String Concatenation in Loops

When concatenating multiple strings in a loop, it's important to be mindful of performance.

Naively using the + operator inside a loop can lead to excessive memory allocations and copies. Here's a more efficient approach using std::string::reserve() and std::string::append():

1#include <iostream>
2#include <string>
3#include <vector>
4
5int main() {
6  std::vector<std::string> words{
7    "Hello", " ", "World", "!"};
8  std::string result;
9
10  // Calculate total length
11  size_t total_length{0};
12  for (const auto& word : words) {
13    total_length += word.length();
14  }
15
16  // Reserve space
17  result.reserve(total_length);  
18
19  // Concatenate strings
20  for (const auto& word : words) {
21    result.append(word);  
22  }
23
24  std::cout << "Result: "
25    << result << '\n';
26  std::cout << "Capacity: "
27    << result.capacity() << '\n';
28  std::cout << "Length: "
29    << result.length() << '\n';
30}

1Result: Hello World!
2Capacity: 12
3Length: 12

Here's why this approach is efficient:

1. We calculate the total length of all strings first.
2. We use reserve() to allocate memory upfront, avoiding multiple reallocations.
3. We use append() instead of + to add each string, which is more efficient for multiple operations.

This method ensures that we only allocate memory once, reducing the overhead of multiple allocations and copies. It's particularly beneficial when dealing with a large number of strings or when performance is critical.

For even better performance with very large strings, you might consider using std::string_view (C++17) for the input strings if you don't need to modify them. This avoids creating unnecessary copies of substrings.

Remember, premature optimization is the root of all evil. Use this technique when you've identified string concatenation as a performance bottleneck in your program.