用另一个子字符串替换子字符串C ++

91

如何用C ++中的另一个子字符串替换字符串中的子字符串，我可以使用哪些函数？ 

eg: string test = "abc def abc def";
test.replace("abc", "hij").replace("def", "klm"); //replace occurrence of abc and def with other substring
c++  string  replace  substring 
— 史蒂文格
source
5
几乎是stackoverflow.com/questions/3418231/…的副本，该副本在公认的答案中提供了更强大的解决方案。
— dave-holm

Answers:

77

C ++中没有一个内置函数可以执行此操作。如果您想将一个子字符串的所有实例替换为另一个子字符串，可以通过混合调用string::find和来实现string::replace。例如：

size_t index = 0;
while (true) {
     /* Locate the substring to replace. */
     index = str.find("abc", index);
     if (index == std::string::npos) break;

     /* Make the replacement. */
     str.replace(index, 3, "def");

     /* Advance index forward so the next iteration doesn't pick it up as well. */
     index += 3;
}

在这段代码的最后一行中，我增加index了插入到字符串中的字符串的长度。在这个特定的示例中-替换"abc"为"def"-实际上并没有必要。但是，在更一般的设置中，跳过刚刚被替换的字符串很重要。例如，如果您要替换"abc"为"abcabc"，而无需跳过新替换的字符串段，则此代码将连续替换新替换的字符串的部分，直到内存用尽。独立地，无论如何跳过这些新字符可能会更快一些，因为这样做可以节省一些时间和精力string::find。

希望这可以帮助！

— templatetypedef
source
6
我不认为您需要增加索引，因为您已经替换了数据，因此无论如何也不会获取它。
— rossb83
1
@Aidiakapi如果将其转换为通用函数，则不会陷入无限循环，因为它将搜索位置（index）移到了替换字符串的那部分之后。
— Tim R.
1
@TimR。您是对的，我回应rossb83时说，索引的增加是不必要的。只是为了防止错误信息。因此对于其他所有人：有必要通过替换的字符串的长度（在本例中为3）增加索引。不要将其从代码示例中删除。
— 2015年
@FrozenKiwi我很惊讶听到这个消息。您确定是这样吗？
— templatetypedef
1
@JulianCienfuegos我刚刚更新了答案来解决这个问题-感谢您指出！（另外，Aidiakapi是其他人……不确定是谁。）
— templatetypedef
68

Boost String Algorithms库方式：

#include <boost/algorithm/string/replace.hpp>

{ // 1. 
  string test = "abc def abc def";
  boost::replace_all(test, "abc", "hij");
  boost::replace_all(test, "def", "klm");
}


{ // 2.
  string test = boost::replace_all_copy
  (  boost::replace_all_copy<string>("abc def abc def", "abc", "hij")
  ,  "def"
  ,  "klm"
  );
}
— 奥列格·斯维奇卡连科（Oleg Svechkarenko）
source
4
周杰伦 我需要提升以替换所有子字符串。
— 约翰内斯·欧弗曼
2
助推器大多是一个过大的杀伤力。
— 康拉德
43

我认为，如果替换字符串的长度与要替换的字符串的长度不同，则所有解决方案都将失败。（搜索“ abc”并替换为“ xxxxxx”）。一般的方法可能是：

void replaceAll( string &s, const string &search, const string &replace ) {
    for( size_t pos = 0; ; pos += replace.length() ) {
        // Locate the substring to replace
        pos = s.find( search, pos );
        if( pos == string::npos ) break;
        // Replace by erasing and inserting
        s.erase( pos, search.length() );
        s.insert( pos, replace );
    }
}
— 旋转最大
source
41 
str.replace(str.find(str2),str2.length(),str3);

哪里

  • str 是基本字符串
  • str2 是要查找的子字符串
  • str3 是替换子字符串
— 杰夫·扎克（Jeff Zacher）
source
3
这只会代替第一次出现，不是吗？
— jpo38
4
我建议确保str.find（str2）的结果不等于std :: string :: npos auto found = str.find（str2）; if（found！= std :: string :: npos）str.replace（found，str2.length（），str3）;
— Geoff Lentsch '17
1
我不打算以此编写整个应用程序，但是如果不对输入进行任何检查，则有一些情况是不确定的....
— Jeff Zacher
19

替换子字符串并不难。

std::string ReplaceString(std::string subject, const std::string& search,
                          const std::string& replace) {
    size_t pos = 0;
    while((pos = subject.find(search, pos)) != std::string::npos) {
         subject.replace(pos, search.length(), replace);
         pos += replace.length();
    }
    return subject;
}

如果需要性能，下面是一个优化的函数，它可以修改输入字符串，但不会创建该字符串的副本：

void ReplaceStringInPlace(std::string& subject, const std::string& search,
                          const std::string& replace) {
    size_t pos = 0;
    while((pos = subject.find(search, pos)) != std::string::npos) {
         subject.replace(pos, search.length(), replace);
         pos += replace.length();
    }
}

测试：

std::string input = "abc abc def";
std::cout << "Input string: " << input << std::endl;

std::cout << "ReplaceString() return value: " 
          << ReplaceString(input, "bc", "!!") << std::endl;
std::cout << "ReplaceString() input string not changed: " 
          << input << std::endl;

ReplaceStringInPlace(input, "bc", "??");
std::cout << "ReplaceStringInPlace() input string modified: " 
          << input << std::endl;

输出：

Input string: abc abc def
ReplaceString() return value: a!! a!! def
ReplaceString() input string not modified: abc abc def
ReplaceStringInPlace() input string modified: a?? a?? def
— 沙雷克·汤姆恰克（Czarek Tomczak）
source
需要添加检查if (search.empty()) { return; }以避免在传递空“搜索”时发生无限循环。
— iOS程序员
尝试过ReplaceString函数-不起作用。但是请回答以下问题：str.replace（str.find（str2），str2.length（），str3）; 只是简单而有效。
— 神风队'17
5 
using std::string;

string string_replace( string src, string const& target, string const& repl)
{
    // handle error situations/trivial cases

    if (target.length() == 0) {
        // searching for a match to the empty string will result in 
        //  an infinite loop
        //  it might make sense to throw an exception for this case
        return src;
    }

    if (src.length() == 0) {
        return src;  // nothing to match against
    }

    size_t idx = 0;

    for (;;) {
        idx = src.find( target, idx);
        if (idx == string::npos)  break;

        src.replace( idx, target.length(), repl);
        idx += repl.length();
    }

    return src;
}

由于它不是string该类的成员，因此它不允许使用与示例中一样好的语法，但是以下操作将等效：

test = string_replace( string_replace( test, "abc", "hij"), "def", "klm")
— 迈克尔·伯尔
source
3

概括rotmax的答案，这是搜索和替换字符串中所有实例的完整解决方案。如果两个子字符串的大小都不同，则使用string :: erase和string :: insert。替换子字符串，否则使用更快的string :: replace。

void FindReplace(string& line, string& oldString, string& newString) {
  const size_t oldSize = oldString.length();

  // do nothing if line is shorter than the string to find
  if( oldSize > line.length() ) return;

  const size_t newSize = newString.length();
  for( size_t pos = 0; ; pos += newSize ) {
    // Locate the substring to replace
    pos = line.find( oldString, pos );
    if( pos == string::npos ) return;
    if( oldSize == newSize ) {
      // if they're same size, use std::string::replace
      line.replace( pos, oldSize, newString );
    } else {
      // if not same size, replace by erasing and inserting
      line.erase( pos, oldSize );
      line.insert( pos, newString );
    }
  }
}
— 尼奥
source
2

如果您确定所需的子字符串出现在字符串中，则它将替换第一次出现"abc"的"hij"

test.replace( test.find("abc"), 3, "hij");

如果您没有测试“ abc”，它将崩溃，因此请谨慎使用。

— ke
source
1

这是我使用构建器策略编写的解决方案：

#include <string>
#include <sstream>

using std::string;
using std::stringstream;

string stringReplace (const string& source,
                      const string& toReplace,
                      const string& replaceWith)
{
  size_t pos = 0;
  size_t cursor = 0;
  int repLen = toReplace.length();
  stringstream builder;

  do
  {
    pos = source.find(toReplace, cursor);

    if (string::npos != pos)
    {
        //copy up to the match, then append the replacement
        builder << source.substr(cursor, pos - cursor);
        builder << replaceWith;

        // skip past the match 
        cursor = pos + repLen;
    }
  } 
  while (string::npos != pos);

  //copy the remainder
  builder << source.substr(cursor);

  return (builder.str());
}

测试：

void addTestResult (const string&& testId, bool pass)
{
  ...
}

void testStringReplace()
{
    string source = "123456789012345678901234567890";
    string toReplace = "567";
    string replaceWith = "abcd";
    string result = stringReplace (source, toReplace, replaceWith);
    string expected = "1234abcd8901234abcd8901234abcd890";

    bool pass = (0 == result.compare(expected));
    addTestResult("567", pass);


    source = "123456789012345678901234567890";
    toReplace = "123";
    replaceWith = "-";
    result = stringReplace(source, toReplace, replaceWith);
    expected = "-4567890-4567890-4567890";

    pass = (0 == result.compare(expected));
    addTestResult("start", pass);


    source = "123456789012345678901234567890";
    toReplace = "0";
    replaceWith = "";
    result = stringReplace(source, toReplace, replaceWith);
    expected = "123456789123456789123456789"; 

    pass = (0 == result.compare(expected));
    addTestResult("end", pass);


    source = "123123456789012345678901234567890";
    toReplace = "123";
    replaceWith = "-";
    result = stringReplace(source, toReplace, replaceWith);
    expected = "--4567890-4567890-4567890";

    pass = (0 == result.compare(expected));
    addTestResult("concat", pass);


    source = "1232323323123456789012345678901234567890";
    toReplace = "323";
    replaceWith = "-";
    result = stringReplace(source, toReplace, replaceWith);
    expected = "12-23-123456789012345678901234567890";

    pass = (0 == result.compare(expected));
    addTestResult("interleaved", pass);



    source = "1232323323123456789012345678901234567890";
    toReplace = "===";
    replaceWith = "-";
    result = utils_stringReplace(source, toReplace, replaceWith);
    expected = source;

    pass = (0 == result.compare(expected));
    addTestResult("no match", pass);

}
— 丹·杰森
source
0 
    string & replace(string & subj, string old, string neu)
    {
        size_t uiui = subj.find(old);
        if (uiui != string::npos)
        {
           subj.erase(uiui, old.size());
           subj.insert(uiui, neu);
        }
        return subj;
    }

我认为这几乎可以满足您的要求！

— 亚历西奥
source
你是不是考虑到多次出现/替换
— 埃利亚斯Bachaalany
0

@Czarek Tomczak的改进版本。
同时允许std::string和std::wstring。

template <typename charType>
void ReplaceSubstring(std::basic_string<charType>& subject,
    const std::basic_string<charType>& search,
    const std::basic_string<charType>& replace)
{
    if (search.empty()) { return; }
    typename std::basic_string<charType>::size_type pos = 0;
    while((pos = subject.find(search, pos)) != std::basic_string<charType>::npos) {
         subject.replace(pos, search.length(), replace);
         pos += replace.length();
    }
}
— iOS程序员
source
0 
std::string replace(const std::string & in
                  , const std::string & from
                  , const std::string & to){
  if(from.size() == 0 ) return in;
  std::string out = "";
  std::string tmp = "";
  for(int i = 0, ii = -1; i < in.size(); ++i) {
    // change ii
    if     ( ii <  0 &&  from[0] == in[i] )  {
      ii  = 0;
      tmp = from[0]; 
    } else if( ii >= 0 && ii < from.size()-1 )  {
      ii ++ ;
      tmp = tmp + in[i];
      if(from[ii] == in[i]) {
      } else {
        out = out + tmp;
        tmp = "";
        ii = -1;
      }
    } else {
      out = out + in[i];
    }
    if( tmp == from ) {
      out = out + to;
      tmp = "";
      ii = -1;
    }
  }
  return out;
};
— 克雷克
source
0

这是使用递归的解决方案，该解决方案将所有出现的子字符串替换为另一个子字符串。无论字符串的大小如何，此方法都有效。

std::string ReplaceString(const std::string source_string, const std::string old_substring, const std::string new_substring)
{
    // Can't replace nothing.
    if (old_substring.empty())
        return source_string;

    // Find the first occurrence of the substring we want to replace.
    size_t substring_position = source_string.find(old_substring);

    // If not found, there is nothing to replace.
    if (substring_position == std::string::npos)
        return source_string;

    // Return the part of the source string until the first occurance of the old substring + the new replacement substring + the result of the same function on the remainder.
    return source_string.substr(0,substring_position) + new_substring + ReplaceString(source_string.substr(substring_position + old_substring.length(),source_string.length() - (substring_position + old_substring.length())), old_substring, new_substring);
}

用法示例：

std::string my_cpp_string = "This string is unmodified. You heard me right, it's unmodified.";
std::cout << "The original C++ string is:\n" << my_cpp_string << std::endl;
my_cpp_string = ReplaceString(my_cpp_string, "unmodified", "modified");
std::cout << "The final C++ string is:\n" << my_cpp_string << std::endl;
— 布罗塔尼亚
source
0 
std::string replace(std::string str, std::string substr1, std::string substr2)
{
    for (size_t index = str.find(substr1, 0); index != std::string::npos && substr1.length(); index = str.find(substr1, index + substr2.length() ) )
        str.replace(index, substr1.length(), substr2);
    return str;
}

不需要任何额外库的简短解决方案。

— Altinsystems
source
这个问题还有14个其他答案。为什么不解释为什么您的身体更好呢？
— chb
0 
std::string replace(std::string str, const std::string& sub1, const std::string& sub2)
{
    if (sub1.empty())
        return str;

    std::size_t pos;
    while ((pos = str.find(sub1)) != std::string::npos)
        str.replace(pos, sub1.size(), sub2);

    return str;
}
— 亚历克斯
source
By using our site, you acknowledge that you have read and understand our Cookie Policy and Privacy Policy.
Licensed under cc by-sa 3.0 with attribution required.