有没有办法用另一个字符串替换所有出现的子字符串std::string？
例如：
void SomeFunction(std::string& str)
{
str = str.replace("hello", "world"); //< I'm looking for something nice like this
}
问问题
120395 次
10 回答
163
#include <boost/algorithm/string.hpp> // include Boost, a C++ library
...
std::string target("Would you like a foo of chocolate. Two foos of chocolate?");
boost::replace_all(target, "foo", "bar");
这是关于 replace_all的官方文档。
于 2010-11-27T03:03:16.660 回答
80
为什么不实施自己的替换？
void myReplace(std::string& str,
const std::string& oldStr,
const std::string& newStr)
{
std::string::size_type pos = 0u;
while((pos = str.find(oldStr, pos)) != std::string::npos){
str.replace(pos, oldStr.length(), newStr);
pos += newStr.length();
}
}
于 2009-09-29T19:21:01.613 回答
41
在 C++11 中，您可以通过调用以下命令来实现这一点regex_replace：
#include <string>
#include <regex>
using std::string;
string do_replace( string const & in, string const & from, string const & to )
{
return std::regex_replace( in, std::regex(from), to );
}
string test = "Remove all spaces";
std::cout << do_replace(test, " ", "") << std::endl;
输出：
Removeallspaces
于 2016-06-21T17:52:37.363 回答
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
于 2013-02-04T00:32:45.457 回答
6
我的模板化内联就地查找和替换：
template<class T>
int inline findAndReplace(T& source, const T& find, const T& replace)
{
int num=0;
typename T::size_t fLen = find.size();
typename T::size_t rLen = replace.size();
for (T::size_t pos=0; (pos=source.find(find, pos))!=T::npos; pos+=rLen)
{
num++;
source.replace(pos, fLen, replace);
}
return num;
}
它返回被替换的项目数的计数（如果您想连续运行，则使用等）。要使用它：
std::string str = "one two three";
int n = findAndReplace(str, "one", "1");
于 2010-11-11T15:46:31.877 回答
3
最简单的方法（提供接近你所写的东西）是使用Boost.Regex，特别是regex_replace。
std::string 内置了 find() 和 replace() 方法，但使用起来更麻烦，因为它们需要处理索引和字符串长度。
于 2009-09-29T19:18:50.307 回答
3
我相信这会奏效。它以 const char* 作为参数。
//params find and replace cannot be NULL
void FindAndReplace( std::string& source, const char* find, const char* replace )
{
//ASSERT(find != NULL);
//ASSERT(replace != NULL);
size_t findLen = strlen(find);
size_t replaceLen = strlen(replace);
size_t pos = 0;
//search for the next occurrence of find within source
while ((pos = source.find(find, pos)) != std::string::npos)
{
//replace the found string with the replacement
source.replace( pos, findLen, replace );
//the next line keeps you from searching your replace string,
//so your could replace "hello" with "hello world"
//and not have it blow chunks.
pos += replaceLen;
}
}
于 2009-09-29T19:26:00.513 回答
3
#include <string>
using std::string;
void myReplace(string& str,
const string& oldStr,
const string& newStr) {
if (oldStr.empty()) {
return;
}
for (size_t pos = 0; (pos = str.find(oldStr, pos)) != string::npos;) {
str.replace(pos, oldStr.length(), newStr);
pos += newStr.length();
}
}
检查 oldStr 是否为空很重要。如果由于某种原因该参数为空，您将陷入无限循环。
但是，如果可以的话，可以使用久经考验的 C++11 或 Boost 解决方案。
于 2017-12-13T14:33:39.377 回答
1
// Replace all occurrences of searchStr in str with replacer
// Each match is replaced only once to prevent an infinite loop
// The algorithm iterates once over the input and only concatenates
// to the output, so it should be reasonably efficient
std::string replace(const std::string& str, const std::string& searchStr,
const std::string& replacer)
{
// Prevent an infinite loop if the input is empty
if (searchStr == "") {
return str;
}
std::string result = "";
size_t pos = 0;
size_t pos2 = str.find(searchStr, pos);
while (pos2 != std::string::npos) {
result += str.substr(pos, pos2-pos) + replacer;
pos = pos2 + searchStr.length();
pos2 = str.find(searchStr, pos);
}
result += str.substr(pos, str.length()-pos);
return result;
}
于 2017-09-21T08:01:44.967 回答
0
性能 O(n) 替换所有
许多其他的答案重复调用std::string::replace，这需要重复覆盖字符串，导致性能不佳。相比之下，这使用了一个std::ostringstream缓冲区，以便字符串的每个字符只被遍历一次：
void replace_all(
std::string& s,
std::string const& toReplace,
std::string const& replaceWith
) {
std::ostringstream oss;
std::size_t pos = 0;
std::size_t prevPos;
while (true) {
prevPos = pos;
pos = s.find(toReplace, pos);
if (pos == std::string::npos)
break;
oss << s.substr(prevPos, pos - prevPos);
oss << replaceWith;
pos += toReplace.size();
}
oss << s.substr(prevPos);
s = oss.str();
}
用法：
replace_all(s, "text to replace", "new text");
完整示例：
#include <iostream>
#include <sstream>
void replace_all(
std::string& s,
std::string const& toReplace,
std::string const& replaceWith
) {
std::ostringstream oss;
std::size_t pos = 0;
std::size_t prevPos;
while (true) {
prevPos = pos;
pos = s.find(toReplace, pos);
if (pos == std::string::npos)
break;
oss << s.substr(prevPos, pos - prevPos);
oss << replaceWith;
pos += toReplace.size();
}
oss << s.substr(prevPos);
s = oss.str();
}
int main() {
std::string s("hello hello, mademoiselle!");
replace_all(s, "hello", "bye");
std::cout << s << std::endl;
}
输出：
bye bye, mademoiselle!
于 2022-01-05T01:35:49.400 回答