Comment rechercher / rechercher et remplacer dans une chaîne standard?

Existe-t-il un moyen de remplacer toutes les occurrences d’une sous-chaîne par une autre chaîne dans std::ssortingng ?

Par exemple:

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

Pourquoi ne pas mettre en œuvre votre propre remplacement?

 void myReplace(std::ssortingng& str, const std::ssortingng& oldStr, const std::ssortingng& newStr) { std::ssortingng::size_type pos = 0u; while((pos = str.find(oldStr, pos)) != std::ssortingng::npos){ str.replace(pos, oldStr.length(), newStr); pos += newStr.length(); } } 
 #include  // include Boost, a C++ library ... std::ssortingng 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.
Voici une présentation que j’ai faite en 2010 sur les algorithmes Boost Ssortingng.

En C ++ 11, vous pouvez le faire en un trait avec un appel à regex_replace :

 #include  #include  using std::ssortingng; ssortingng do_replace( ssortingng const & in, ssortingng const & from, ssortingng const & to ) { return std::regex_replace( in, std::regex(from), to ); } ssortingng test = "Remove all spaces"; std::cout < < do_replace(test, " ", "") << std::endl; 

sortie:

 Removeallspaces 

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

 std::ssortingng ReplaceSsortingng(std::ssortingng subject, const std::ssortingng& search, const std::ssortingng& replace) { size_t pos = 0; while((pos = subject.find(search, pos)) != std::ssortingng::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 ReplaceSsortingngInPlace(std::ssortingng& subject, const std::ssortingng& search, const std::ssortingng& replace) { size_t pos = 0; while((pos = subject.find(search, pos)) != std::ssortingng::npos) { subject.replace(pos, search.length(), replace); pos += replace.length(); } } 

Tests:

 std::ssortingng 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 ssortingng: abc abc def ReplaceSsortingng() return value: a!! a!! def ReplaceSsortingng() input ssortingng not modified: abc abc def ReplaceSsortingngInPlace() input ssortingng modified: a?? a?? def 

Mon in-situ in-situ sur site est:

 template 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; } 

Il renvoie le nombre d’éléments remplacés (à utiliser si vous voulez l’exécuter successivement, etc.). Pour l’utiliser:

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

La méthode la plus simple (proposer quelque chose près de ce que vous avez écrit) consiste à utiliser Boost.Regex , en particulier regex_replace .

std :: ssortingng a intégré les méthodes find () et replace (), mais elles sont plus difficiles à utiliser car elles nécessitent des index et des longueurs de chaîne.

Je crois que cela fonctionnerait. Il prend const char * comme paramètre.

 //params find and replace cannot be NULL void FindAndReplace( std::ssortingng& source, const char* find, const char* replace ) { //ASSERT(find != NULL); //ASSERT(replace != NULL); size_t findLen = strlen(find); size_t replaceLen = strlen(replace); size_t pos = 0; //search for the next occurrence of find within source while ((pos = source.find(find, pos)) != std::ssortingng::npos) { //replace the found ssortingng with the replacement source.replace( pos, findLen, replace ); //the next line keeps you from searching your replace ssortingng, //so your could replace "hello" with "hello world" //and not have it blow chunks. pos += replaceLen; } } 
 #include  #include  #include  #include  #include  using namespace boost::algorithm; using namespace std; using namespace boost; void highlighter(ssortingng terms, ssortingng text) { char_separator sep(" "); tokenizer > tokens(terms, sep); BOOST_FOREACH(ssortingng term, tokens) { boost::replace_all(text, term, "" + term + ""); } cout < < text << endl; } int main(int argc, char **argv) { cout << "Search term highlighter" << endl; string text("I love boost library, and this is a test of boost library!"); highlighter("love boost", text); } 

J'adore la librairie boost , et c'est un test de librairie boost !

 // Replace all occurrences of searchStr in str with replacer // Each match is replaced only once to prevent an infinite loop // The algorithm iterates once over the input and only concatenates // to the output, so it should be reasonably efficient std::ssortingng replace(const std::ssortingng& str, const std::ssortingng& searchStr, const std::ssortingng& replacer) { // Prevent an infinite loop if the input is empty if (searchStr == "") { return str; } std::ssortingng result = ""; size_t pos = 0; size_t pos2 = str.find(searchStr, pos); while (pos2 != std::ssortingng::npos) { result += str.substr(pos, pos2-pos) + replacer; pos = pos2 + searchStr.length(); pos2 = str.find(searchStr, pos); } result += str.substr(pos, str.length()-pos); return result; } 
 #include  using std::ssortingng; void myReplace(ssortingng& str, const ssortingng& oldStr, const ssortingng& newStr) { if (oldStr.empty()) { return; } for (size_t pos = 0; (pos = str.find(oldStr, pos)) != ssortingng::npos;) { str.replace(pos, oldStr.length(), newStr); pos += newStr.length(); } } 

Le contrôle de oldStr étant vide est important. Si pour une raison quelconque ce paramètre est vide, vous serez bloqué dans une boucle infinie.

Mais oui, utilisez la solution C ++ 11 ou Boost si vous le pouvez.