C++中replace()函数使用方法汇总

前言

C++ 里叫replace的东西有两个，初学者经常混淆。一个是std::string的成员函数replace()，用于把字符串中的某一段替换成另一段；另一个是<algorithm>里的std::replace()算法，用于把容器中等于某个值的元素全部改成另一个值。前者操作的是「子串」，后者操作的是「元素」，参数和语义完全不同。

std::string::replace本身也不是一个函数，而是一组重载：可以按下标指定范围，也可以按迭代器指定范围；替换内容可以是另一个字符串、C 风格字符串、字符区间，或者若干个重复的字符。重载多带来的直接后果是——调用时参数个数或类型稍有偏差，就可能匹配到另一个重载，产生意料之外的行为，甚至编译错误。

初学者常见的错误有三类。第一是把第二个参数当成「结束位置」，实际上它是「要删除的字符个数」。第二是替换全部时忘记推进查找位置，如果替换内容里又包含被替换的子串，就会陷入死循环。第三是不检查find的返回值，把npos直接传给replace，触发std::out_of_range异常。

本文按「两个 replace 的区别 → 下标版本 → 迭代器版本 → 填充与删除 → 全部替换」的顺序梳理，最后给出完整示例和常见错误。所有函数签名以 C++17 的std::string为准。

一、两个 replace 的区别

std::replace的签名是void replace(ForwardIt first, ForwardIt last, const T& old_value, const T& new_value)，它遍历区间，把每个等于old_value的元素赋值为new_value。对std::string使用它，效果是「把所有某个字符换成另一个字符」：

// 适用于 C++17
#include <algorithm>
#include <string>

std::string s = "banana";
std::replace(s.begin(), s.end(), 'a', 'o'); // s 变成 "bonono"

它不能替换子串，也不能改变字符串长度。要替换子串，必须用成员函数replace。

二、按下标替换

最常用的形式是：

// 适用于 C++17
std::string s = "hello world";
s.replace(6, 5, "there");
// s 现在是 "hello there"

参数含义：

1. 
   
2. 6：起始下标；
3. 
   
4. 5：要删除的字符个数；
5. 
   
6. "there"：替换成的内容。
7. 
   

关键点：第二个参数是长度，不是结束下标。写成s.replace(6, 11, "there")表示「从下标 6 开始删掉 11 个字符」，而不是「替换到下标 11」。

按下标版本的主要重载：

几个边界规则：

• 
  
• pos必须不大于size()，否则抛std::out_of_range；
• 
  
• pos == size()合法，相当于在末尾追加；
• 
  
• count可以超过剩余长度，超出部分会被截断为「到末尾为止」；
• 
  
• 删除一段内容，可以把替换内容写成空串：s.replace(pos, count, "")。
• 
  

// 适用于 C++17
#include <string>

std::string s = "abcdef";
s.replace(2, 3, "XY"); // "abXYf"
s.replace(0, 0, ">> "); // ">> abXYf"，在开头插入
s.replace(s.size(), 0, "!"); // 在末尾追加
s.replace(1, 2, ""); // 删除下标 1 开始的 2 个字符

三、按迭代器替换

迭代器版本适合「已经通过find或其它算法定位到区间」的场景：

// 适用于 C++17
#include <string>

std::string s = "hello world";
auto first = s.begin() + 6;
auto last = s.begin() + 11;
s.replace(first, last, "there");

对应的重载包括：

使用迭代器版本时要注意：替换会让迭代器失效。replace可能改变字符串长度，导致重新分配。如果替换后还要继续使用原来的first、last，必须重新获取。标准规定replace返回*this的引用，方便链式调用，但不返回新的迭代器。

四、填充与删除

用重复字符填充是replace的一个实用形式：

// 适用于 C++17
#include <string>

std::string s = "secret";
s.replace(0, s.size(), 6, '*'); // "******"

这里第三个参数是「重复次数」，第四个参数是字符。注意不能写成s.replace(0, 6, '*')——'*'是char，无法匹配「C 风格字符串」的重载，编译器会报找不到匹配的函数。要填充字符，必须写「次数 + 字符」两个参数。

删除则是「用空串替换」：

// 适用于 C++17
std::string s = "abcdef";
s.replace(1, 3, ""); // "aef"

也可以用s.erase(1, 3)，语义更直接。erase和replace在删除场景下等价，但erase的命名更能表达意图。C++20 还提供了std::erase/std::erase_if用于容器，与成员函数erase不是一回事。

五、替换全部

std::string没有「替换全部」的成员函数，需要自己循环：

// 适用于 C++17
#include <cstddef>
#include <string>

std::size_t replaceAll(std::string& s, const std::string& from,
const std::string& to) {
if (from.empty()) return 0; // 空模式会导致死循环

std::size_t count = 0;
std::size_t pos = 0;
while ((pos = s.find(from, pos)) != std::string::npos) {
s.replace(pos, from.size(), to);
pos += to.size(); // 跳过刚插入的内容
++count;
}
return count;
}

两个细节决定了这段代码是否正确：

1. 
   
2. from为空时必须直接返回。find("")永远返回当前pos，而replace(pos, 0, to)又会在原地插入内容，循环永远不会结束。
3. 
   
4. 替换后pos += to.size()。如果只写pos += from.size()，当to中包含from时（比如把"aa"替换成"aaa"），新插入的内容会被再次匹配，导致无限增长。跳过整个替换结果，才能保证每次循环都严格向后推进。
5. 
   

如果不希望替换后的内容被再次匹配，这是正确的行为；如果业务上确实需要「替换到不再变化」，那要另外设计终止条件，不能靠这个循环。

六、完整示例

// 适用于 C++17
#include <algorithm>
#include <cstddef>
#include <iostream>
#include <string>

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

int main() {
// 1. 按下标替换
std::string a = "hello world";
a.replace(6, 5, "there");
std::cout << a << '\n'; // 按语义应当是 hello there

// 2. 用重复字符填充
std::string b = "secret";
b.replace(0, b.size(), b.size(), '*');
std::cout << b << '\n'; // 按语义应当是 ******

// 3. 按迭代器替换
std::string c = "abcdef";
const auto first = c.begin() + 1;
const auto last = c.begin() + 4;
c.replace(first, last, "XY");
std::cout << c << '\n'; // 按语义应当是 aXYef

// 4. 全部替换
std::string d = "one two one two one";
const std::size_t n = replaceAll(d, "one", "1");
std::cout << d << '\n'; // 按语义应当是 1 two 1 two 1
std::cout << "replaced " << n << " times\n";

// 5. 算法版 replace：替换单个字符
std::string e = "banana";
std::replace(e.begin(), e.end(), 'a', 'o');
std::cout << e << '\n'; // 按语义应当是 bonono
return 0;
}

第 2 段里b.replace(0, b.size(), b.size(), '*')的第三个参数用了b.size()，它在调用前求值，此时b.size()是 6，得到 6 个星号。如果把替换长度和填充个数写成同一个变量，要注意求值顺序——这里的两个b.size()都在replace执行前求值，不存在「边改边读」的问题。

常见坑点

1. 把第二个参数当成结束下标

❌s.replace(2, 5, "x")以为替换[2, 5)✅s.replace(2, 5 - 2, "x")，第二个参数是长度

replace(pos, count, ...)的count是「删除多少个字符」。把结束下标直接传进去，会多删或少删。

2. 把 npos 传给 replace

❌s.replace(s.find("x"), 1, "y")而find返回npos✅ 先判断pos != std::string::npos，再替换

npos是一个极大的无符号数，作为pos传入会超出size()，replace抛出std::out_of_range。未捕获的异常会让程序终止。

3. 替换全部时死循环

❌pos = s.find(from); s.replace(pos, from.size(), to);循环中pos不前进 ✅ 每次替换后pos += to.size()

如果to包含from，不前进就会反复匹配刚插入的内容，字符串无限增长直到耗尽内存。

4. 空模式导致死循环

❌replaceAll(s, "", "x")✅ 函数开头if (from.empty()) return 0;

find("")永远成功，replace(pos, 0, to)又不会消耗原字符，循环无法终止。

5. 用字符填充却少传一个参数

❌s.replace(0, 3, '*')✅s.replace(0, 3, 3, '*')

replace没有「删除 count 个字符并替换成一个 char」的重载。'*'无法匹配 C 字符串参数，编译失败。填充字符必须写「个数 + 字符」。

6. 混淆 std::replace 与成员 replace

❌std::replace(s.begin(), s.end(), "a", "b");✅std::replace(s.begin(), s.end(), 'a', 'b');或s.replace(pos, 1, "b")

std::replace比较的是元素类型char，传字符串字面量类型不匹配。它也不能改变字符串长度。

7. 替换后继续使用旧迭代器

❌auto it = s.begin(); s.replace(0, 1, "long text"); use(it);✅ 替换后重新获取迭代器，或改用下标

replace可能触发重新分配，所有迭代器、指针、引用失效。继续使用是未定义行为。

8. 越界 pos 未捕获

❌s.replace(100, 1, "x")而s.size()只有 10 ✅ 替换前检查pos <= s.size()，或捕获std::out_of_range

pos > size()时replace抛异常。这类错误在解析外部输入时很常见，应当显式校验下标来源。

总结

std::string::replace的重载虽多，日常用到的其实只有三四种：按下标替换、按下标删除、用字符填充、按迭代器替换。记住两条规则就不会出大错——第二个参数是长度不是下标，替换全部要推进查找位置。至于std::replace，它属于算法库，处理的是「元素相等就替换」，和子串替换是两回事，不要在两者之间混用。