std :: regex_replace替换n次出现并获得替换数

Question

I'm using std::regex_replace to modify the string. I need both to restrict substitutions made and to get number of them done.

I used following code:

std::wregex rx(pattern);
size_t n = 0; // one match
size_t ns = 3;
wstring result = src;
wstring old; // old value
bool replaced = false;

do {
    old = result;
    result = std::regex_replace(result, rx, replace, std::regex_constants::format_first_only);
    replaced = result != old;
    if (replaced)
        n++;
} while (replaced && n < ns); 

It works fine, I can both restrict substitutuins amount and get their number. But this code analyzes the string from its start, as a result, if I have following values:

"banana" for src, "(an)" for pattern and "$1-" for replace

it produces following output: ban---ana instead of ban-an-a. Obviously, this is because std::regex_replace analyzes string from start. A solution might be to use iterators to define first character to analyze, but in this case I need to get iterator that points to characters after those that were replcased, but how can I get it?

Answer 1

This turned out to be trickier than I thought. I didn't find any of the std::regex_replace() functions very helpful here.

I decided to go with a straight std::wsregex_iterator solution based on the algorithm suggested in the implementation descriptions here:

http://en.cppreference.com/w/cpp/regex/regex_replace

This is what I came up with:

#include <regex>
#include <string>
#include <iterator>
#include <iostream>

int main()
{
    std::size_t ns = 3;
    std::wstring text = L"banana";
    std::wstring pattern = L"(an)";
    std::wstring replace = L"$1-";
    std::wstring result;

    std::wregex rx(pattern);

    auto iter = std::wsregex_iterator(text.begin(), text.end(), rx);
    auto stop = std::wsregex_iterator();
    auto last_iter = iter;

    auto out = std::back_inserter(result);

    for(std::size_t n = ns; n-- && iter != stop; ++iter)
    {
        out = std::copy(iter->prefix().first, iter->prefix().second, out);
        out = iter->format(out, replace);
        last_iter = iter;
    }

    out = std::copy(last_iter->suffix().first, last_iter->suffix().second, out);

    std::wcout << "  text: " << text << '\n';
    std::wcout << "result: " << result << '\n';
}

Output:

  text: banana
result: ban-an-a

Answer 2

You can set up a counter and use a callback. This will only replace the maximum you set.
(Untested)

static int REPL_count = 0;
static int REPL_max = 0;
static string REPL_replace = "";


string REPLcallback( const wsmatch m )
{
    // Return formatted match if under the max count
    if ( REPL_count < REPL_max )
    {
        ++REPL_count;
        return m.format( REPL_replace );
    }
    // Exceeded count, just return match without formatting
    return string(m[0].first, m[0].second);
}

int ReplaceText(
         string& strIn,
         string& strOut,
         wregex  Regex,
         string& strReplacement,
         int     max )
{
    REPL_count = 0;
    REPL_max = max;
    REPL_replace = strReplacement;
    strOut = regex_replace( strIn, Regex, REPLcallback );
    return REPL_count;
}