Reemplazar subcadena con otra subcadena C++

¿Cómo podría reemplazar una subcadena en una cadena con otra subcadena en C++, qué funciones podría usar?

eg: string test = "abc def abc def";
test.replace("abc", "hij").replace("def", "klm"); //replace occurrence of abc and def with other substring

En c ++ 11, puede usar std::regex_replace:

#include <string>
#include <regex>

std::string test = "abc def abc def";
test = std::regex_replace(test, std::regex("def"), "klm"); // replace 'def' -> 'klm'
// test = "abc klm abc klm"

No hay una función integrada en C++ para hacer esto. Si desea reemplazar todas las instancias de una subcadena con otra, puede hacerlo mezclando llamadas a string::find y string::replace. Por ejemplo:

size_t index = 0;
while (true) {
     /* Locate the substring to replace. */
     index = str.find("abc", index);
     if (index == std::string::npos) break;

     /* Make the replacement. */
     str.replace(index, 3, "def");

     /* Advance index forward so the next iteration doesn't pick it up as well. */
     index += 3;
}

En la última línea de este código, he incrementado index por la longitud de la cadena que se ha insertado en la cadena. En este ejemplo particular – reemplazando "abc" con "def" – esto no es realmente necesario. Sin embargo, en una configuración más general, es importante pasar por alto la cadena que acaba de ser reemplazada. Por ejemplo, si desea reemplazar "abc" con "abcabc", sin omitir el segmento de cadena recién reemplazado, este código reemplazaría continuamente partes de las cadenas recién reemplazadas hasta que se agotara la memoria. Independientemente, podría ser un poco más rápido saltear esos nuevos caracteres de todos modos, ya que al hacerlo se ahorra algo de tiempo y esfuerzo por parte del string::find función.

¡Espero que esto ayude!

Biblioteca de algoritmos Boost String manera:

#include <boost/algorithm/string/replace.hpp>

{ // 1. 
  string test = "abc def abc def";
  boost::replace_all(test, "abc", "hij");
  boost::replace_all(test, "def", "klm");
}


{ // 2.
  string test = boost::replace_all_copy
  (  boost::replace_all_copy<string>("abc def abc def", "abc", "hij")
  ,  "def"
  ,  "klm"
  );
}

Creo que todas las soluciones fallarán si la longitud de la cadena de reemplazo es diferente de la longitud de la cadena que se reemplazará. (busque “abc” y reemplácelo por “xxxxxx”) Un enfoque general podría ser:

void replaceAll( string &s, const string &search, const string &replace ) {
    for( size_t pos = 0; ; pos += replace.length() ) {
        // Locate the substring to replace
        pos = s.find( search, pos );
        if( pos == string::npos ) break;
        // Replace by erasing and inserting
        s.erase( pos, search.length() );
        s.insert( pos, replace );
    }
}

str.replace(str.find(str2),str2.length(),str3);

Donde

• str es la cadena base
• str2 es la subcadena a encontrar
• str3 es la subcadena de reemplazo

Reemplazar subcadenas no debería ser tan difícil.

std::string ReplaceString(std::string subject, const std::string& search,
                          const std::string& replace) {
    size_t pos = 0;
    while((pos = subject.find(search, pos)) != std::string::npos) {
         subject.replace(pos, search.length(), replace);
         pos += replace.length();
    }
    return subject;
}

Si necesita rendimiento, aquí hay una función optimizada que modifica la cadena de entrada, no crea una copia de la cadena:

void ReplaceStringInPlace(std::string& subject, const std::string& search,
                          const std::string& replace) {
    size_t pos = 0;
    while((pos = subject.find(search, pos)) != std::string::npos) {
         subject.replace(pos, search.length(), replace);
         pos += replace.length();
    }
}

Pruebas:

std::string input = "abc abc def";
std::cout << "Input string: " << input << std::endl;

std::cout << "ReplaceString() return value: " 
          << ReplaceString(input, "bc", "!!") << std::endl;
std::cout << "ReplaceString() input string not changed: " 
          << input << std::endl;

ReplaceStringInPlace(input, "bc", "??");
std::cout << "ReplaceStringInPlace() input string modified: " 
          << input << std::endl;

Producción:

Input string: abc abc def
ReplaceString() return value: a!! a!! def
ReplaceString() input string not modified: abc abc def
ReplaceStringInPlace() input string modified: a?? a?? def

using std::string;

string string_replace( string src, string const& target, string const& repl)
{
    // handle error situations/trivial cases

    if (target.length() == 0) {
        // searching for a match to the empty string will result in 
        //  an infinite loop
        //  it might make sense to throw an exception for this case
        return src;
    }

    if (src.length() == 0) {
        return src;  // nothing to match against
    }

    size_t idx = 0;

    for (;;) {
        idx = src.find( target, idx);
        if (idx == string::npos)  break;

        src.replace( idx, target.length(), repl);
        idx += repl.length();
    }

    return src;
}

Como no es miembro de la string clase, no permite una sintaxis tan agradable como en su ejemplo, pero lo siguiente hará el equivalente:

test = string_replace( string_replace( test, "abc", "hij"), "def", "klm")