Comment rechercher/trouver et remplacer dans une chaîne de caractères standard ?

Question

Existe-t-il un moyen de remplacer toutes les occurrences d'une sous-chaîne par une autre chaîne de caractères dans l'application std::string ?

Par exemple :

void SomeFunction(std::string& str)
{
   str = str.replace("hello", "world"); //< I'm looking for something nice like this
}

Answer 1

#include <boost/algorithm/string.hpp> // include Boost, a C++ library
...
std::string target("Would you like a foo of chocolate. Two foos of chocolate?");
boost::replace_all(target, "foo", "bar");

Voici la documentation officielle sur replace_all.

Answer 2

Pourquoi ne pas mettre en place votre propre remplacement ?

void myReplace(std::string& str,
               const std::string& oldStr,
               const std::string& newStr)
{
  std::string::size_type pos = 0u;
  while((pos = str.find(oldStr, pos)) != std::string::npos){
     str.replace(pos, oldStr.length(), newStr);
     pos += newStr.length();
  }
}

Answer 3

Pourquoi ne pas renvoyer une chaîne modifiée ?

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 vous avez besoin de performances, voici une fonction optimisée qui modifie la chaîne d'entrée, elle ne crée pas de copie de la chaîne :

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();
    }
}

Tests :

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;

Sortie :

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

Answer 4

Mon modèle de recherche et de remplacement en ligne :

template<class T>
int inline findAndReplace(T& source, const T& find, const T& replace)
{
    int num=0;
    typename T::size_t fLen = find.size();
    typename T::size_t rLen = replace.size();
    for (T::size_t pos=0; (pos=source.find(find, pos))!=T::npos; pos+=rLen)
    {
        num++;
        source.replace(pos, fLen, replace);
    }
    return num;
}

Elle retourne un compte du nombre d'éléments substitués (à utiliser si vous voulez exécuter successivement ceci, etc). Pour l'utiliser :

std::string str = "one two three";
int n = findAndReplace(str, "one", "1");

Answer 5

Le moyen le plus simple (offrant quelque chose de proche de ce que vous avez écrit) est d'utiliser Boost.Regex et plus particulièrement regex_replace .

std::string possède des méthodes find() et replace() intégrées, mais elles sont plus difficiles à utiliser car elles nécessitent de traiter des indices et des longueurs de chaîne.