[re.alg.replace]

🔗

template<class OutputIterator, class BidirectionalIterator,
          class traits, class charT, class ST, class SA>
  OutputIterator
    regex_replace(OutputIterator out,
                  BidirectionalIterator first, BidirectionalIterator last,
                  const basic_regex<charT, traits>& e,
                  const basic_string<charT, ST, SA>& fmt,
                  regex_constants::match_flag_type flags = regex_constants::match_default);
template<class OutputIterator, class BidirectionalIterator, class traits, class charT>
  OutputIterator
    regex_replace(OutputIterator out,
                  BidirectionalIterator first, BidirectionalIterator last,
                  const basic_regex<charT, traits>& e,
                  const charT* fmt,
                  regex_constants::match_flag_type flags = regex_constants::match_default);

Effects: Constructs a regex_iterator object i as if by

regex_iterator<BidirectionalIterator, charT, traits> i(first, last, e, flags)

and uses i to enumerate through all of the matches m of type match_results<BidirectionalIterator> that occur within the sequence [first, last).

If no such matches are found and !(flags & regex_constants::format_no_copy), then calls

out = copy(first, last, out)

If any matches are found then, for each such match:

(1.1)
If !(flags & regex_constants::format_no_copy), calls
```
out = copy(m.prefix().first, m.prefix().second, out)
```

(1.2)

Then calls

out = m.format(out, fmt, flags)

for the first form of the function and

out = m.format(out, fmt, fmt + char_traits<charT>::length(fmt), flags)

for the second.

Finally, if such a match is found and !(flags & regex_constants::format_no_copy), calls

out = copy(last_m.suffix().first, last_m.suffix().second, out)

where last_m is a copy of the last match found.

If flags & regex_constants::format_first_only is nonzero, then only the first match found is replaced.

🔗

template<class traits, class charT, class ST, class SA, class FST, class FSA>
  basic_string<charT, ST, SA>
    regex_replace(const basic_string<charT, ST, SA>& s,
                  const basic_regex<charT, traits>& e,
                  const basic_string<charT, FST, FSA>& fmt,
                  regex_constants::match_flag_type flags = regex_constants::match_default);
template<class traits, class charT, class ST, class SA>
  basic_string<charT, ST, SA>
    regex_replace(const basic_string<charT, ST, SA>& s,
                  const basic_regex<charT, traits>& e,
                  const charT* fmt,
                  regex_constants::match_flag_type flags = regex_constants::match_default);

Effects: Constructs an empty string result of type basic_string<charT, ST, SA> and calls:

regex_replace(back_inserter(result), s.begin(), s.end(), e, fmt, flags);

Returns: result.

🔗

template<class traits, class charT, class ST, class SA>
  basic_string<charT>
    regex_replace(const charT* s,
                  const basic_regex<charT, traits>& e,
                  const basic_string<charT, ST, SA>& fmt,
                  regex_constants::match_flag_type flags = regex_constants::match_default);
template<class traits, class charT>
  basic_string<charT>
    regex_replace(const charT* s,
                  const basic_regex<charT, traits>& e,
                  const charT* fmt,
                  regex_constants::match_flag_type flags = regex_constants::match_default);

30 Regular expressions library [re]

30.11 Regular expression algorithms [re.alg]

30.11.4 regex_replace [re.alg.replace]

30 Regular expressions library [re]

30.11 Regular expression algorithms [re.alg]

30.11.4 regex_­replace [re.alg.replace]

30.11.4 regex_replace [re.alg.replace]