将字符串的一部分替换为另一个字符串

使用 std：：string：：replace：

s.replace(s.find("$name"), sizeof("$name") - 1, "Somename");

是的，你可以这样做，但你必须用字符串的 find（） 成员找到第一个字符串的位置，然后用它的 replace（） 成员替换。

string s("hello $name");
size_type pos = s.find( "$name" );
if ( pos != string::npos ) {
   s.replace( pos, 5, "somename" );   // 5 = length( $name )
}

如果你打算使用标准库，你真的应该得到一份C++标准库这本书的副本，它很好地涵盖了所有这些东西。

有一个函数用于查找字符串中的子字符串 （find），还有一个函数用于将字符串中的特定范围替换为另一个字符串 （replace），因此您可以将它们组合在一起以获得所需的效果：

bool replace(std::string& str, const std::string& from, const std::string& to) {
    size_t start_pos = str.find(from);
    if(start_pos == std::string::npos)
        return false;
    str.replace(start_pos, from.length(), to);
    return true;
}

std::string string("hello $name");
replace(string, "$name", "Somename");

---

在回应评论时，我认为可能看起来像这样：replaceAll

void replaceAll(std::string& str, const std::string& from, const std::string& to) {
    if(from.empty())
        return;
    size_t start_pos = 0;
    while((start_pos = str.find(from, start_pos)) != std::string::npos) {
        str.replace(start_pos, from.length(), to);
        start_pos += to.length(); // In case 'to' contains 'from', like replacing 'x' with 'yx'
    }
}

若要返回新字符串，请使用以下命令：

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 modified: " 
          << 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

std::string replace(std::string base, const std::string from, const std::string to) {
    std::string SecureCopy = base;

    for (size_t start_pos = SecureCopy.find(from); start_pos != std::string::npos; start_pos = SecureCopy.find(from,start_pos))
    {
        SecureCopy.replace(start_pos, from.length(), to);
    }

    return SecureCopy;
}

我通常使用这个：

std::string& replace(std::string& s, const std::string& from, const std::string& to)
{
    if(!from.empty())
        for(size_t pos = 0; (pos = s.find(from, pos)) != std::string::npos; pos += to.size())
            s.replace(pos, from.size(), to);
    return s;
}

它反复调用以查找搜索字符串的其他匹配项，直到找不到任何内容。因为返回匹配的位置，所以我们没有使迭代器无效的问题。std::string::find()std::string::find()std::string::find()

使用 C++11，您可以像这样使用：std::regex

#include <regex>
...
std::string string("hello $name");
string = std::regex_replace(string, std::regex("\\$name"), "Somename");

转义转义字符需要双反斜杠。

string.replace(string.find("%s"), string("%s").size(), "Something");

你可以把它包装在一个函数中，但这个单行解决方案听起来是可以接受的。 问题是这只会改变第一次出现，你可能想循环它，但它也允许你使用相同的标记 （） 将多个变量插入到这个字符串中。%s

我现在正在学习C++，但是编辑之前发布的一些代码，我可能会使用这样的东西。这使您可以灵活地替换 1 个或多个实例，还可以指定起点。

using namespace std;

// returns number of replacements made in string
long strReplace(string& str, const string& from, const string& to, size_t start = 0, long count = -1) {
    if (from.empty()) return 0;

    size_t startpos = str.find(from, start);
    long replaceCount = 0;

    while (startpos != string::npos){
        str.replace(startpos, from.length(), to);
        startpos += to.length();
        replaceCount++;

        if (count > 0 && replaceCount >= count) break;
        startpos = str.find(from, startpos);
    }

    return replaceCount;
}

wstring myString = L"Hello $$ this is an example. By $$.";
wstring search = L"$$";
wstring replace = L"Tom";
for (int i = myString.find(search); i >= 0; i = myString.find(search))
    myString.replace(i, search.size(), replace);

如果所有字符串都是 std：：string，那么如果使用，你会发现字符截断的奇怪问题，因为它适用于 C 字符串，而不是 C++ 字符串。解决方法是使用 的 类方法。sizeof().size()std::string

sHaystack.replace(sHaystack.find(sNeedle), sNeedle.size(), sReplace);

这取代了内联的 sHaystack -- 无需对它进行 = 赋值。

用法示例：

std::string sHaystack = "This is %XXX% test.";
std::string sNeedle = "%XXX%";
std::string sReplace = "my special";
sHaystack.replace(sHaystack.find(sNeedle),sNeedle.size(),sReplace);
std::cout << sHaystack << std::endl;

如果你想快速完成，你可以使用两次扫描的方法。 伪代码：

1. 首先解析。查找匹配的字符数。
2. 展开字符串的长度。
3. 第二次解析。当我们得到一个匹配项时，从字符串的末尾开始，我们替换，否则我们只是从第一个字符串复制字符。

我不确定这是否可以优化为就地算法。

还有一个 C++11 代码示例，但我只搜索一个字符。

#include <string>
#include <iostream>
#include <algorithm>
using namespace std;

void ReplaceString(string& subject, char search, const string& replace)
{   
    size_t initSize = subject.size();
    int count = 0;
    for (auto c : subject) { 
        if (c == search) ++count;
    }

    size_t idx = subject.size()-1 + count * replace.size()-1;
    subject.resize(idx + 1, '\0');

    string reverseReplace{ replace };
    reverse(reverseReplace.begin(), reverseReplace.end());  

    char *end_ptr = &subject[initSize - 1];
    while (end_ptr >= &subject[0])
    {
        if (*end_ptr == search) {
            for (auto c : reverseReplace) {
                subject[idx - 1] = c;
                --idx;              
            }           
        }
        else {
            subject[idx - 1] = *end_ptr;
            --idx;
        }
        --end_ptr;
    }
}

int main()
{
    string s{ "Mr John Smith" };
    ReplaceString(s, ' ', "%20");
    cout << s << "\n";

}

我自己的实现，考虑到该字符串只需要调整一次大小，然后就可以进行替换。

template <typename T>
std::basic_string<T> replaceAll(const std::basic_string<T>& s, const T* from, const T* to)
{
    auto length = std::char_traits<T>::length;
    size_t toLen = length(to), fromLen = length(from), delta = toLen - fromLen;
    bool pass = false;
    std::string ns = s;

    size_t newLen = ns.length();

    for (bool estimate : { true, false })
    {
        size_t pos = 0;

        for (; (pos = ns.find(from, pos)) != std::string::npos; pos++)
        {
            if (estimate)
            {
                newLen += delta;
                pos += fromLen;
            }
            else
            {
                ns.replace(pos, fromLen, to);
                pos += delta;
            }
        }

        if (estimate)
            ns.resize(newLen);
    }

    return ns;
}

例如，用法可以如下所示：

std::string dirSuite = replaceAll(replaceAll(relPath.parent_path().u8string(), "\\", "/"), ":", "");

这可能更好使用

void replace(string& input, const string& from, const string& to)
{
    auto pos = 0;
    while(true)
    {
        size_t startPosition = input.find(from, pos);
        if(startPosition == string::npos)
            return;
        input.replace(startPosition, from.length(), to);
        pos += to.length();
    }
}

您可以使用此代码来删除减法，也可以替换 ，还可以删除多余的空格。 法典：

#include<bits/stdc++.h>
using namespace std;

void removeSpaces(string &str)
{   
    int n = str.length();
    int i = 0, j = -1;

    bool spaceFound = false;
    while (++j <= n && str[j] == ' ');

    while (j <= n)
    {
        if (str[j] != ' ')
        {
          
            if ((str[j] == '.' || str[j] == ',' ||
                 str[j] == '?') && i - 1 >= 0 &&
                 str[i - 1] == ' ')
                str[i - 1] = str[j++];
            else str[i++] = str[j++];
 
            spaceFound = false;
        }
        else if (str[j++] == ' ')
        {
            if (!spaceFound)
            {
                str[i++] = ' ';
                spaceFound = true;
            }
        }
    }

    if (i <= 1)
         str.erase(str.begin() + i, str.end());
    else str.erase(str.begin() + i - 1, str.end());
}
int main()
{
    string s;
    cin >> s;

    for(int i = s.find("WUB"); i >= 0; i = s.find("WUB"))
        s.replace(i,3," ");
    removeSpaces(s);
    cout << s << endl;

    return 0;
}

升压解决方案怎么样：

boost::replace_all(value, "token1", "token2");

这是一个使用 c++ 标准库的行。

替换最好不要包含旧字符串（例如：替换为 ），否则您将遇到 INFINITE LOOP。此外，与其他技术相比，对于大型字符串来说，它的速度很慢，因为每次查找操作都从字符串调用的开头开始。如果您不太懒，请寻找更好的解决方案。我把它放进去是为了完整和启发其他人。你已经被警告过了。,,,

while(s.find(old_s) != string::npos) s.replace(s.find(old_s), old_s.size(), new_s);

还有一个 lambda 选项

auto replaceAll = [](string& s, string o, string n){ while(s.find(o) != string::npos) s.replace(s.find(o), o.size(), n); };

// EXAMPLES:
// Used like
string text = "hello hello world";
replaceAll(text, "hello", "bye"); // Changes text to "bye bye world"
// Do NOT use like
string text = "hello hello world";
replaceAll(text, "hello", "hello hello"); // Loops forever

它需要一些案例分析来为所有输入编写最佳（或至少不是二次）算法。

朴素算法（也是在撰写本文时获得最多票数的答案）在最坏的情况下是二次的，因为它在每次迭代时都会移动整个后缀，因此由于这种移动，它是 O（n） 调用 replace（），O（n） 每个调用。

从本质上讲，大海捞针字符串可以看作是一系列等于 的字符串，由其他一些字符串（没有子字符串）分隔。因此，为了避免二次运行时，我们需要做的就是确保我们只复制每个这样的字符串一次，而不是每次都复制整个后缀或前缀。它可以通过“双指针技术”来实现，我们这样做的确切方式取决于谁更长：whatwhat

• 如果替换将缩小字符串（即短于 ），那么让我们从字符串的开头开始并保持两个偏移量 - 读取和写入一个 - 并且写入的偏移量永远不会更大。遍历整个字符串（只需一次就地遍历）后，写入偏移量代表我们复制的最后一个字符，因此它也是字符串的新大小。withwhat
• 如果替换将增加字符串（ 长于 ），我们将做类似的事情，但向后。要知道从哪个写入偏移量开始，我们必须知道出现的次数并提前调整字符串的大小，否则它与前一种情况非常对称。withwhat
• 如果 和 的长度相等，我们就不必移动字符串，所以几乎任何方法都足够了——第一种方法看起来更好，因为它只需要一次传递。withwhat

#include <algorithm>
#include <cassert>
#include <cstddef>
#include <string>
#include <string_view>

size_t CountOccurrences(std::string_view s, std::string_view needle) {
    size_t res = 0;
    size_t pos = 0;
    while ((pos = s.find(needle, pos)) != std::string_view::npos) {
        ++res;
        pos += needle.size();
    }
    return res;
}

std::string ReplaceNotLonger(std::string s, std::string_view what, std::string_view with) {
    assert(what.size() >= with.size());
    std::string_view::size_type wpos = 0;
    std::string_view::size_type rpos = 0;
    while (true) {
        auto new_rpos = s.find(what, rpos);
        if (new_rpos == std::string::npos) {
            new_rpos = s.size();
        }
        auto n = new_rpos - rpos;
        std::copy(s.begin() + rpos, s.begin() + new_rpos, s.begin() + wpos);
        wpos += n;
        rpos = new_rpos;
        if (rpos == s.size()) {
            break;
        }
        std::copy(with.begin(), with.end(), s.begin() + wpos);
        wpos += with.size();
        rpos += what.size();
    }
    s.resize(wpos);
    return s;
}

std::string ReplaceLonger(std::string s, std::string_view what, std::string_view with) {
    assert(what.size() < with.size());
    auto occurrences = CountOccurrences(s, what);
    auto rpos = s.size();
    auto wpos = rpos + occurrences * (with.size() - what.size());
    s.resize(wpos);
    
    while (wpos != rpos) {
        auto new_rpos = s.rfind(what, rpos - what.size());
        if (new_rpos == std::string::npos) {
            new_rpos = 0;
        } else {
            new_rpos += what.size();
        }
        auto n = rpos - new_rpos;
        std::copy_backward(s.begin() + new_rpos, s.begin() + rpos, s.begin() + wpos);
        wpos -= n;
        rpos = new_rpos;
        if (wpos == rpos) {
            break;
        }
        std::copy_backward(with.begin(), with.end(), s.begin() + wpos);
        wpos -= with.size();
        rpos -= what.size();
    }
    return s;
}

std::string Replace(std::string s, std::string_view what, std::string_view with) {
    assert(!what.empty());
    if (what.size() >= with.size()) {
        return ReplaceNotLonger(std::move(s), what, with);
    }
    return ReplaceLonger(std::move(s), what, with);
}