std::regex_replace - cppreference.com

De cppreference.com

Definido en el archivo de encabezado `<regex>`
`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 );`	(1)	(desde C++11)
`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 );`	(2)	(desde C++11)
`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>& s, 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 );`	(3)	(desde C++11)
`template< class Traits, class CharT, class STraits, class SAlloc > std::basic_string<CharT,STraits,SAlloc> regex_replace( const std::basic_string<CharT,STraits,SAlloc>& s, const std::basic_regex<CharT,Traits>& re, const CharT* fmt, std::regex_constants::match_flag_type flags = std::regex_constants::match_default );`	(4)	(desde C++11)
`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 );`	(5)	(desde C++11)
`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 );`	(6)	(desde C++11)

regex_replace utiliza una expresión regular para realizar sustitución en una secuencia de caracteres:

1) Copia los caracteres en el rango [first,last) a out, reemplazando cualquier secuencia que coincide con re con caracteres formateados mediante fmt. En otras palabras:

Construye un objeto std::regex_iterator i como si fuera por std::regex_iterator<BidirIt, CharT, traits> i(first, last, re, flags), y lo utiliza para recorrer cada coincidencia de re dentro de la secuencia [first,last).
Para cada tal coincidencia m, copia la subsecuencia que no se coincidió (m.prefix()) a out como si fuera por out = std::copy(m.prefix().first, m.prefix().second, out) y luego reemplaza la subsecuencia que se coincidió con la cadena de reemplazo formateada como si fuera mediante una llamada a out = m.format(out, fmt, flags).
Cuando no se encuentran más coincidencias, copia los caracteres restantes que no se coincidieron a out como si fuera por out = std::copy(last_m.suffix().first, last_m.suffix().second, out) donde last_m es una copia de la última coincidencia encontrada.
Si no hay coincidencias, copia toda la secuencia en out tal como es, mediante out = std::copy(first, last, out)
Si flags contiene std::regex_constants::format_no_copy, las subsecuencias que no se coincidieron se copian en out.
Si flags contiene std::regex_constants::format_first_only, solo se reemplaza la primera coincidencia.

3-4) Construye una cadena vacía result de tipo std::basic_string<CharT, ST, SA> y llama a std::regex_replace(std::back_inserter(result), s.begin(), s.end(), re, fmt, flags).

5-6) Construye una cadena vacía result de tipo std::basic_string<CharT> y llama a std::regex_replace(std::back_inserter(result), s, s + std::char_traits<CharT>::length(s), re, fmt, flags).

Parámetros

first, last	-	La secuencia de caracteres de entrada, representada como un par de iteradores.
s	-	La secuencia de caracteres de entrada, representada como std::basic_string o un array de caracteres.
re	-	El std::basic_regex que se hará coincidir frente a la secuencia de entrada.
flags	-	Los indicadores de coincidencia de tipo std::regex_constants::match_flag_type.
fmt	-	La cadena de formato de reemplazo de la espresión regular, la sintaxis exacta depende del valor de `flags`.
out	-	El iterador de salida para almacenar el resultado del reemplazo.
Requisitos de tipo
-`OutputIt` debe satisfacer los requisitos de OutputIterator.
-`BidirIt` debe satisfacer los requisitos de BidirectionalIterator.

Valor de retorno

1-2) Devuelve una copia del iterador de salida out después de todas las inserciones.

3-6) Devuelve la cadena result que contiene la salida.

Excepciones

Puede lanzar std::regex_error para indicar una condición de error.

Ejemplo

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

int main()
{
   // texto y expresión regular (er) para vocales
   std::string texto = "La zorra veloz";
   std::regex er_vocales("a|e|i|o|u");

   // escribir el resultado a un iterador de salida
   std::regex_replace(std::ostreambuf_iterator<char>(std::cout),
                      texto.begin(), texto.end(), er_vocales, "*");

   // construir una cadena que alberga el resultado
   std::cout << '\n' << std::regex_replace(texto, er_vocales, "[$&]") << '\n';
}

Salida:

L* z*rra v*l*z
L[a] z[o]rr[a] v[e]l[o]z

Véase también

	Intenta coincidir una expresión regular con cualquier parte de una secuencia de caracteres. (plantilla de función) [editar]
	Opciones específicas para coincidencias. (typedef) [editar]
	Reemplaza todas las apariciones de los caracteres especificados (función miembro pública de `std::basic_string`) [editar]