Replacing All Substrings in a String

Replacing all occurrences of a substring within a std::string is a common operation in text processing. While C++ doesn't have a built-in replace_all() function, we can implement one efficiently. Here's a robust approach:

1#include <iostream>
2#include <string>
3
4std::string replace_all(
5  std::string str,
6  const std::string& from,
7  const std::string& to
8) {
9  size_t start_pos{0};
10  while (
11    (start_pos = str.find(from, start_pos))
12    != std::string::npos
13  ) {
14    str.replace(start_pos, from.length(), to);
15
16    // In case 'to' contains 'from', like
17    // replacing 'x' with 'yx'
18    start_pos += to.length();
19  }
20  return str;
21}
22
23int main() {
24  std::string text{
25    "The quick brown fox jumps over the lazy dog"};
26  std::string from{"o"};
27  std::string to{"0"};
28
29  std::cout << "Original: " << text << '\n';
30  std::cout << "Replaced: "
31    << replace_all(text, from, to) << '\n';
32
33  // Another example
34  text = "Hello, Hello, Hello!";
35  from = "Hello";
36  to = "Hi";
37  std::cout << "Original: " << text << '\n';
38  std::cout << "Replaced: "
39    << replace_all(text, from, to) << '\n';
40}

1Original: The quick brown fox jumps over the lazy dog
2Replaced: The quick br0wn f0x jumps 0ver the lazy d0g
3Original: Hello, Hello, Hello!
4Replaced: Hi, Hi, Hi!

Let's break down the replace_all() function:

1. We use std::string::find() to locate each occurrence of the from substring.
2. We replace each occurrence using std::string::replace().
3. We update start_pos to continue searching after the replaced substring.

This approach is efficient because:

• It modifies the string in-place, avoiding unnecessary allocations.
• It handles cases where the replacement string contains the search string.
• It uses std::string's built-in methods, which are typically optimized.

For more complex pattern matching and replacing, you might consider using regular expressions:

1#include <regex>
2
3std::string regex_replace_all(
4  const std::string& str,
5  const std::string& from,
6  const std::string& to
7) {
8  return std::regex_replace(
9    str, std::regex(from), to
10  );
11}

However, be aware that regex operations can be slower for simple replacements. Use them when you need more complex pattern matching capabilities.

For very large strings or performance-critical code, you might want to consider using a more sophisticated string searching algorithm like Boyer-Moore or Knuth-Morris-Pratt. These can be more efficient for long strings or when doing many replacements.

Remember, the most appropriate method depends on your specific use case, including the size of your strings, the complexity of your patterns, and your performance requirements.