View source for cpp/regex/regex replace

You do not have permission to edit this page, for the following reason:

Due to recent vandalism, editing of this page is temporarily disabled for new users.If you want to suggest a change, please leave a message on the suggestions page for new users instead (don't be surprised if that page appears vandalized!).

You can view and copy the source of this page:

{{cpp/title|regex_replace}}
{{cpp/regex/navbar}}
{{dcl begin}}
{{dcl header|regex}}
{{dcl|num=1|since=c++11|1=
template< class OutputIt, class BidirIt, class Traits, class CharT,
          class STraits, class SAlloc >
OutputIt regex_replace( OutputIt out, BidirIt first, BidirIt last,
                        const std::basic_regex<CharT, Traits>& re,
                        const std::basic_string<CharT, STraits, SAlloc>& fmt,
                        std::regex_constants::match_flag_type flags =
                            std::regex_constants::match_default );
}}
{{dcl|num=2|since=c++11|1=
template< class OutputIt, class BidirIt, class Traits, class CharT >
OutputIt regex_replace( OutputIt out, BidirIt first, BidirIt last,
                        const std::basic_regex<CharT, Traits>& re,
                        const CharT* fmt,
                        std::regex_constants::match_flag_type flags =
                            std::regex_constants::match_default );
}}
{{dcl|num=3|since=c++11|1=
template< class Traits, class CharT,
          class STraits, class SAlloc, class FTraits, class FAlloc >
std::basic_string<CharT, STraits, SAlloc>
    regex_replace( const std::basic_string<CharT, STraits, SAlloc>& str,
                   const std::basic_regex<CharT, Traits>& re,
                   const std::basic_string<CharT, FTraits, FAlloc>& fmt,
                   std::regex_constants::match_flag_type flags =
                       std::regex_constants::match_default );
}}
{{dcl|num=4|since=c++11|1=
template< class Traits, class CharT, class STraits, class SAlloc >
std::basic_string<CharT, STraits, SAlloc>
    regex_replace( const std::basic_string<CharT, STraits, SAlloc>& str,
                   const std::basic_regex<CharT, Traits>& re,
                   const CharT* fmt,
                   std::regex_constants::match_flag_type flags =
                       std::regex_constants::match_default );
}}
{{dcl|num=5|since=c++11|1=
template< class Traits, class CharT, class STraits, class SAlloc >
std::basic_string<CharT>
    regex_replace( const CharT* s, const std::basic_regex<CharT, Traits>& re,
                   const std::basic_string<CharT, STraits, SAlloc>& fmt,
                   std::regex_constants::match_flag_type flags =
                       std::regex_constants::match_default );
}}
{{dcl|num=6|since=c++11|1=
template< class Traits, class CharT >
std::basic_string<CharT>
    regex_replace( const CharT* s, const std::basic_regex<CharT, Traits>& re,
                   const CharT* fmt,
                   std::regex_constants::match_flag_type flags =
                       std::regex_constants::match_default );
}}
{{dcl end}}

{{tt|regex_replace}} uses the regular expression {{c|re}} to perform substitution on the target character sequence:

@1,2@ Copies characters in the range {{range|first|last}} to {{c|out}}, replacing any sequences that match {{c|re}} with characters formatted by {{c|fmt}}. Equivalent to:
{{source|1=
using iter_type = std::regex_iterator<BidirIt, CharT, Traits>;
iter_type seq_begin(first, last, re, flags), seq_end;

using result_type = std::match_results<BidirIt>;
result_type m;

bool need_to_copy = (flags & std::regex_constants::format_no_copy) == 0;
bool format_all = (flags & std::regex_constants::format_first_only) != 0;

for (iter_type i = seq_begin; i != seq.end(); ++i)
{
    m = *i;
    if (need_to_copy)
        out = std::copy(m.prefix().first, m.prefix().second, out);
    if (format_all {{!!}} i == seq_begin)
        out = /* replace-expr */
}

if (need_to_copy)
    out = m.ready()
              ? std::copy(m.suffix().first, m.suffix().second, out)
              : std::copy(first, last, out);

return out;
}}
:@1@ The expression {{c|/* replace-expr */}} is {{c|m.format(out, fmt, flags)}}.
:@2@ The expression {{c|/* replace-expr */}} is {{c|m.format(out, fmt, fmt + std::char_traits<CharT>::length(fmt), flags)}}.

@3,4@ Equivalent to {{c multi|std::basic_string<CharT, STraits, SAlloc> result;|regex_replace(std::back_inserter(result),|              str.begin(), str.end(), re, fmt, flags);|return result;}}.

@5,6@ Equivalent to {{c multi|std::basic_string<CharT, STraits, SAlloc> result;|regex_replace(std::back_inserter(result),|              s, s + std::char_traits<CharT>::length(s), re, fmt, flags);|return result;}}. 

===Parameters===
{{par begin}}
{{par|first, last|the target character range}}
{{par|str|the target {{lc|std::string}}}}
{{par|s|the target null-terminated C-style string}}
{{par|re|the regular expression}}
{{par|fmt|the regex replacement format string, exact syntax depends on the value of {{c|flags}}}}
{{par|flags|flags used to determine how the match will be performed}}
{{par|out|output iterator to store the result of the replacement}}
{{par end}}

===Return value===
As described above.

===Exceptions===
May throw {{lc|std::regex_error}} to indicate an [[cpp/regex/error_type|error condition]].

===Example===
{{example
|code=
#include <iostream>
#include <iterator>
#include <regex>
#include <string>

int main()
{
    std::string text = "Quick brown fox";
    std::regex vowel_re("a{{!}}e{{!}}i{{!}}o{{!}}u");
    
    // write the results to an output iterator
    std::regex_replace(std::ostreambuf_iterator<char>(std::cout),
                       text.begin(), text.end(), vowel_re, "*");
    
    // construct a string holding the results
    std::cout << '\n' << std::regex_replace(text, vowel_re, "[$&]") << '\n';
}
|output=
Q**ck br*wn f*x
Q[u][i]ck br[o]wn f[o]x
}}

===Defect reports===
{{dr list begin}}
{{dr list item|wg=lwg|dr=2213|std=C++11|before={{c|out}} was not updated by the replacements|after={{c|out}} is updated}}
{{dr list end}}

===See also===
{{dsc begin}}
{{dsc inc|cpp/regex/dsc regex_search}}
{{dsc inc|cpp/regex/dsc match_flag_type}}
{{dsc inc|cpp/string/basic_string/dsc replace}}
{{dsc end}}

{{langlinks|de|es|fr|it|ja|pt|ru|zh}}

Templates used on this page:

Template:! (view source) (protected)
Template:!! (edit)
Template:box (edit)
Template:box/core (edit)
Template:c (view source) (protected)
Template:c multi (edit)
Template:c/core (view source) (protected)
Template:cpp/navbar content (edit)
Template:cpp/navbar heading (edit)
Template:cpp/regex/dsc match flag type (edit)
Template:cpp/regex/dsc regex search (edit)
Template:cpp/regex/navbar (edit)
Template:cpp/regex/navbar content (edit)
Template:cpp/regex/navbar heading (edit)
Template:cpp/string/basic string/dsc replace (edit)
Template:cpp/string/basic string/title (edit)
Template:cpp/text/navbar content (edit)
Template:cpp/text/navbar heading (edit)
Template:cpp/title (view source) (protected)
Template:ctitle (view source) (protected)
Template:dcl (view source) (protected)
Template:dcl begin (view source) (protected)
Template:dcl end (view source) (protected)
Template:dcl header (view source) (protected)
Template:dcl list header/link (edit)
Template:dcl sep (view source) (protected)
Template:dcl/std (view source) (semi-protected)
Template:dr list begin (edit)
Template:dr list end (edit)
Template:dr list item (edit)
Template:dsc (view source) (protected)
Template:dsc begin (view source) (protected)
Template:dsc editlink (edit)
Template:dsc end (view source) (protected)
Template:dsc guard (view source) (protected)
Template:dsc header/link (edit)
Template:dsc inc (view source) (protected)
Template:dsc mark mem (view source) (protected)
Template:dsc mem fun (view source) (protected)
Template:dsc member (view source) (protected)
Template:dsc tfun (view source) (protected)

cppreference.com

Namespaces

Variants

Views

Actions

View source for cpp/regex/regex replace