如何在C++中修改并替换std::regex/boost::regex正则匹配的多个捕获组内容

我完全理解你的需求——你有一个包含多个捕获组的长正则表达式，匹配后需要对每个捕获组的内容做自定义处理（甚至是多个捕获组联动的处理），再把处理后的内容替换回原字符串的对应位置，还希望尽量兼容std::regex和boost::regex。下面给你几个实用的解决方案：

方案一：手动拼接结果字符串（全兼容方案） #

这个方法是最直观也最兼容的，不管你用std::regex还是boost::regex都能直接用。因为match_results（也就是你代码里的smatch）会保存每个捕获组在原字符串中的精确位置，我们可以利用这些位置来拼接出最终的结果：

#include <string>
#include <regex> // 或者boost/regex.hpp

using namespace std; // 如果用boost就换成using namespace boost;

// 假设已经完成匹配，m是有效的smatch对象
string s1 = m[1], s2 = m[2], s3 = m[3];
compute_replacements(s1, s2, s3); // 你的自定义处理函数，修改s1、s2、s3

string result;
result.reserve(s.size()); // 预分配内存提升效率

// 拼接原字符串开头到第一个捕获组的前半部分
result.append(s.begin(), m[1].first);
// 加入处理后的第一个捕获组
result += s1;
// 拼接第一个捕获组结束到第二个捕获组开始的部分
result.append(m[1].second, m[2].first);
// 加入处理后的第二个捕获组
result += s2;
// 拼接第二个捕获组结束到第三个捕获组开始的部分
result.append(m[2].second, m[3].first);
// 加入处理后的第三个捕获组
result += s3;
// 拼接第三个捕获组结束到原字符串末尾的部分
result.append(m[3].second, s.end());

这个方案的优势在于完全可控，不管你的捕获组处理逻辑有多复杂（哪怕是多个捕获组联动修改），都能轻松实现，而且没有库兼容问题。

方案二：使用带回调的替换函数（Boost更便捷） #

如果你使用boost::regex，可以利用它支持自定义替换回调的特性，让代码更简洁。而std::regex虽然没有直接的回调替换，但也可以通过类似的思路实现：

Boost版本 #

#include <boost/regex.hpp>
#include <string>

using namespace boost;

// 自定义替换回调函数
string custom_replace(const match_results<string::const_iterator>& m) {
    string s1 = m[1], s2 = m[2], s3 = m[3];
    compute_replacements(s1, s2, s3); // 你的自定义处理逻辑

    string result;
    // 拼接匹配前缀（原字符串中匹配部分之前的内容）
    result.append(m.prefix());
    // 依次拼接处理后的捕获组和它们之间的原内容
    result += s1;
    result.append(m[1].second, m[2].first);
    result += s2;
    result.append(m[2].second, m[3].first);
    result += s3;
    // 拼接匹配后缀（原字符串中匹配部分之后的内容）
    result.append(m.suffix());
    return result;
}

// 使用方式
string s("123 hello 456 a,b,c 789 1:2:3");
regex r(R"regex(\d+ (\w+) \d+ ([\w,]+) \d+ ([\w:]+))regex");
string result = regex_replace(s, r, custom_replace);

C++标准库版本 #

标准库的std::regex_replace默认只支持$1、$2这类固定占位符替换，如果要实现回调式的自定义替换，本质上还是要回到方案一的手动拼接逻辑，不过可以把它封装成一个函数，让调用更简洁：

#include <string>
#include <regex>

using namespace std;

template<typename Func>
string regex_replace_custom(const string& s, const regex& r, Func&& replace_func) {
    smatch m;
    if (!regex_match(s, m, r)) {
        return s; // 匹配失败直接返回原字符串
    }
    return replace_func(m);
}

// 使用方式
string result = regex_replace_custom(s, r, [&](const smatch& m) {
    string s1 = m[1], s2 = m[2], s3 = m[3];
    compute_replacements(s1, s2, s3);
    
    string res;
    res.reserve(s.size());
    res.append(s.begin(), m[1].first);
    res += s1;
    res.append(m[1].second, m[2].first);
    res += s2;
    res.append(m[2].second, m[3].first);
    res += s3;
    res.append(m[3].second, s.end());
    return res;
});

补充说明 #

如果你的捕获组处理逻辑是完全独立的（比如每个捕获组只需要自己单独处理，不需要和其他捕获组联动），那可以直接用regex_replace的占位符语法，比如：

// 假设reverse_str是反转字符串的函数
string result = regex_replace(s, r, "$1" + reverse_str(m[2]) + "$3"); // 举个例子，实际需要根据逻辑调整

但你提到处理逻辑不是独立的，所以前面的手动拼接或回调方案才是更适合的选择。

备注：内容来源于stack exchange，提问作者nonagon