如何在没有正则表达式的情况下在 C++ 中实现有效的全字字符串替换？

Question

也许我忽略了一些显而易见的事情，但我想知道在 C++ 中实现全字字符串替换的最快方法可能是什么。起初我考虑只是将空格连接到搜索词，但这没有考虑字符串边界或标点符号。

这是我目前对（非全词）替换的抽象：

void Replace(wstring& input, wstring find, wstring replace_with) {
  if (find.empty() || find == replace_with || input.length() < find.length()) {
      return;
  }
  for (size_t pos = input.find(find); 
              pos != wstring::npos; 
              pos = input.find(find, pos)) {

      input.replace(pos, find.length(), replace_with);
      pos += replace_with.length();
  }
}

如果我只将空格视为单词边界，我可以通过将搜索字符串的开头和结尾与查找字符串进行比较以覆盖字符串边界，然后使用 Replace(L' ' + find + L' ')....但我想知道是否有更优雅的解决方案可以有效地包含标点符号。

让我们认为一个单词是由空格或标点符号分隔的任何字符集合（为了简单起见，我们说！”#$%&'()*+,-./ 至少 - 这恰好发生在对应(c > 31 && c < 48))。

在我的应用程序中，我必须在相当大的短字符串数组上调用此函数，其中可能包括我不想拆分新单词的各种 Unicode。我也想避免包含任何外部库，但 STL 很好。

不使用正则表达式的目的是保证更少的开销，以及在大型数据集上适合此特定任务的快速函数的目标。

Answer 1

我认为您可以做到这一点，既可以进行全词匹配，也可以有效地进行。关键是：

• 使用 'std::isalpha' 检测“全字”边界，应该适用于 Unicode 和任何语言环境。
• 通过创建一个单独的“输出”字符串来替换“不合适”，在处理结束时将其与“输入”交换，而不是在“输入”字符串本身“就地”进行工作。

这是我对你的功能的看法：

#include <cctype> // isalpha
#include <ciso646> // or, not
#include <string> // wstring

using std::size_t;
using std::wstring;

/// @brief Do a "find and replace" on a string.
/// @note This function does "whole-word" matching.
/// @param[in,out] input_string The string to operate on.
/// @param[in] find_string The string to find in the input.
/// @param[in] replace_string The string to replace 'find_string'
///            with in the input.
void find_and_replace( wstring& input_string,
                       const wstring& find_string,
                       const wstring& replace_string )
{
  if( find_string.empty()
      or find_string == replace_string
      or input_string.length() < find_string.length() )
  {
    return;
  }

  wstring output_string;
  output_string.reserve( input_string.length() );
  size_t last_pos = 0u;
  for( size_t new_pos = input_string.find( find_string );
       new_pos != wstring::npos;
       new_pos = input_string.find( find_string, new_pos ) )
  {
    bool did_replace = false;
    if( ( new_pos == 0u
          or not std::isalpha( input_string.at( new_pos - 1u ) ) )
        and ( new_pos + find_string.length() == input_string.length()
              or not std::isalpha( input_string.at( new_pos + find_string.length() ) ) ) )
    {
      output_string.append( input_string, last_pos, new_pos - last_pos );
      output_string.append( replace_string );
      did_replace = true;
    }
    new_pos += find_string.length();
    if( did_replace )
    {
      last_pos = new_pos;
    }
  }
  output_string.append( input_string, last_pos,
                        input_string.length() - last_pos );

  input_string.swap( output_string );
}

附：我不确定“replace_all”在您最初的示例中试图完成什么，因此为了清楚起见，我将其从解决方案中删除。

P.P.S.使用 Regex-es，这段代码会更干净。您可以依赖 C++ TR1 或 C++ 2011 功能吗？他们提供了一个标准的“正则表达式”库。

Answer 2

这是我的快速回复，但不知道解决方案有多快...... 这个问题的解决方案很少：
1.通过使用迭代器，比较每个单词（由空格分隔），为每个出现重新创建字符串：

string& remove_all_occurences(string& s, const string& str_to_remove, const string& str_to_put){
                typedef string::size_type string_size;
                string_size i = 0;
                string cur_string;
                cur_string.reserve(s.size());

                // invariant: we have processed characters [original value of i, i) 
                while (i != s.size()) {
                // ignore leading blanks
                // invariant: characters in range [original i, current i) are all spaces
                    while (i != s.size() && isspace(s[i]))
                    ++i;

                    // find end of next word
                    string_size j = i;
                    // invariant: none of the characters in range [original j, current j)is a space
                     while (j != s.size() && !isspace(s[j]))
                        j++;
                        // if we found some nonwhitespace characters 


                    if (i != j) {
                        // copy from s starting at the beginning to i, placing str to replace, and finishing with j to the end of s
                        cur_string = s.substr(i,j-i);
                        if(cur_string == str_to_remove){
                            s = s.substr(0,i) + str_to_put + s.substr(j,s.size() - j);
                        }
                        i = j;
                    }
                }
                return s;
            }

测试程序：

void call_remove_all_occurences(){
                string my_str = "The quick brown fox jumps over sleepy dog fox fox fox";
                cout << remove_all_occurences(my_str,"fox","godzilla") << endl;
            }

输出：

The quick brown godzilla jumps over sleepy dog godzilla godzilla godzilla

1. 通过将字符串拆分为向量，而不是遍历向量并替换每个出现 - 简单...没有代码，但您明白了...