Reemplazar parte de una cadena con otra cadena

Con C++11 puedes usar std::regex así:

    std::string string("hello $name");
    string = std::regex_replace(string, std::regex("\\$name"), "Somename");

La doble barra invertida es necesaria para escapar un carácter de escape.

std::string tiene un replace método, ¿es eso lo que estás buscando?

Puedes probar:

s.replace(s.find("$name"), sizeof("Somename")-1, "Somename");

No lo he intentado, solo lea la documentación en find() y replace().

Para que se devuelva la nueva cadena use esto:

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 modified: " 
          << input << std::endl;

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

Salida:

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

Sí, puedes hacerlo, pero tienes que encontrar la posición de la primera cadena con el miembro find() de la cadena, y luego reemplazarla con su miembro replace ().

string s("hello $name");
size_type pos = s.find( "$name" );
if ( pos != string::npos ) {
   s.replace( pos, 5, "somename" );   // 5 = length( $name )
}

Si está planeando usar la Biblioteca Estándar, realmente debería obtener una copia del libro The C++ Standard Library que cubre todo esto muy bien.

Esto suena como una opción

string.replace(string.find("%s"), string("%s").size(), "Something");

Podría envolver esto en una función, pero esta solución de una línea suena aceptable. El problema es que esto solo cambiará la primera ocurrencia, es posible que desee hacer un bucle sobre ella, pero también le permite insertar varias variables en esta cadena con el mismo token (%s)

Si todas las cadenas son std::string, encontrará problemas extraños con el corte de caracteres si usa sizeof() porque está destinado a cadenas de C, no a cadenas de C++. La solución es usar el método de clase .size() de std::string.

sHaystack.replace(sHaystack.find(sNeedle), sNeedle.size(), sReplace);

Que reemplaza a sHaystack inline no no hay necesidad de hacer una asignación = de nuevo en eso.

Ejemplo de uso:

std::string sHaystack = "This is %XXX% test.";
std::string sNeedle = "%XXX%";
std::string sReplace = "my special";
sHaystack.replace(sHaystack.find(sNeedle),sNeedle.size(),sReplace);
std::cout << sHaystack << std::endl;

std::string replace(std::string base, const std::string from, const std::string to) {
    std::string SecureCopy = base;

    for (size_t start_pos = SecureCopy.find(from); start_pos != std::string::npos; start_pos = SecureCopy.find(from,start_pos))
    {
        SecureCopy.replace(start_pos, from.length(), to);
    }

    return SecureCopy;
}

Uso generalmente esto:

std::string& replace(std::string& s, const std::string& from, const std::string& to)
{
    if(!from.empty())
        for(size_t pos = 0; (pos = s.find(from, pos)) != std::string::npos; pos += to.size())
            s.replace(pos, from.size(), to);
    return s;
}

Llama repetidamente a std::string::find() para localizar otras ocurrencias de la cadena buscada hasta que std::string::find() no encuentre nada. Debido a que std::string::find()devuelve la posición de la coincidencia, no tenemos el problema de invalidar los iteradores.

Si desea hacerlo rápidamente, puede usar un enfoque de dos escaneos. Pseudo código:

1. primer análisis. encuentra cuántos caracteres coinciden.
2. expanda la longitud de la cadena.
3. segundo análisis. Comience desde el final de la cadena cuando obtenemos una coincidencia que reemplazamos, de lo contrario solo copiamos los caracteres de la primera cadena.

No estoy seguro de si esto se puede optimizar a un algo in situ.

Y un ejemplo de código C++11, pero solo busco un char.

#include <string>
#include <iostream>
#include <algorithm>
using namespace std;

void ReplaceString(string& subject, char search, const string& replace)
{   
    size_t initSize = subject.size();
    int count = 0;
    for (auto c : subject) { 
        if (c == search) ++count;
    }

    size_t idx = subject.size()-1 + count * replace.size()-1;
    subject.resize(idx + 1, '\0');

    string reverseReplace{ replace };
    reverse(reverseReplace.begin(), reverseReplace.end());  

    char *end_ptr = &subject[initSize - 1];
    while (end_ptr >= &subject[0])
    {
        if (*end_ptr == search) {
            for (auto c : reverseReplace) {
                subject[idx - 1] = c;
                --idx;              
            }           
        }
        else {
            subject[idx - 1] = *end_ptr;
            --idx;
        }
        --end_ptr;
    }
}

int main()
{
    string s{ "Mr John Smith" };
    ReplaceString(s, ' ', "%20");
    cout << s << "\n";

}

Ahora estoy aprendiendo C++, pero editando parte del código publicado anteriormente, probablemente usaría algo como esto. Esto le da la flexibilidad de reemplazar 1 o varias instancias, y también le permite especificar el punto de inicio.

using namespace std;

// returns number of replacements made in string
long strReplace(string& str, const string& from, const string& to, size_t start = 0, long count = -1) {
    if (from.empty()) return 0;

    size_t startpos = str.find(from, start);
    long replaceCount = 0;

    while (startpos != string::npos){
        str.replace(startpos, from.length(), to);
        startpos += to.length();
        replaceCount++;

        if (count > 0 && replaceCount >= count) break;
        startpos = str.find(from, startpos);
    }

    return replaceCount;
}

wstring myString = L"Hello $$ this is an example. By $$.";
wstring search = L"$$";
wstring replace = L"Tom";
for (int i = myString.find(search); i >= 0; i = myString.find(search))
    myString.replace(i, search.size(), replace);