std::regex_replace

 

C++

Apoyo de compiladores

Implementaciones independientes y albergadas

Lenguaje

Biblioteca estándar

Encabezados de la biblioteca estándar

Requisitos denominados

Macros de prueba de característica (C++20)

Biblioteca de apoyo del lenguaje

Biblioteca de conceptos (C++20)

Biblioteca de diagnósticos

Biblioteca de gestión de memoria

Biblioteca de metaprogramación (C++11)

Biblioteca de servicios generales

Biblioteca de contenedores

Biblioteca de iteradores

Biblioteca de rangos (C++20)

Biblioteca de algoritmos

Biblioteca de cadenas

Biblioteca de procesamiento de texto

Biblioteca numérica

Biblioteca de fecha y hora

Biblioteca de entrada/salida

Biblioteca del sistema de archivos (C++17)

Biblioteca de apoyo de concurrencia (C++11)

Biblioteca de apoyo de ejecución (C++26)

Especificaciones técnicas

Índice de símbolos

Bibliotecas externas

 

Biblioteca de expresiones regulares

Clases

basic_regex (C++11)

sub_match (C++11)

match_results (C++11)

Algoritmos

regex_match (C++11)

regex_search (C++11)

regex_replace (C++11)

Iteradores

regex_iterator (C++11)

regex_token_iterator (C++11)

Excepciones

regex_error (C++11)

Rasgos

regex_traits (C++11)

Constantes

syntax_option_type (C++11)

match_flag_type (C++11)

error_type (C++11)

Gramática de las expresiones regulares

ECMAScript-262 modificado (C++11)

 

<tbody> </tbody>

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)

See More

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.

2) Igual que (4), pero el reemplazo formateado se ejecuta como si fuera mediante la llamada a out = m.format(out, fmt, fmt + char_traits<charT>::length(fmt), flags)

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

Ejecuta este código

#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

regex_search (C++11)	Intenta coincidir una expresión regular con cualquier parte de una secuencia de caracteres. (plantilla de función)
match_flag_type (C++11)	Opciones específicas para coincidencias. (typedef)
replace	Reemplaza todas las apariciones de los caracteres especificados (función miembro pública de std::basic_string)