web-dev-qa-db-fra.com

Comment trouver et remplacer la chaîne?

Si s est un std::string, existe-t-il une fonction semblable à celle-ci?

s.replace("text to replace", "new text");
c++string
48
neuromancer

Essayez une combinaison de std::string::find et std::string::replace .

Cela obtient la position:

std::string s;
std::string toReplace("text to replace");
size_t pos = s.find(toReplace);

Et ceci remplace l'occurrence first:

s.replace(pos, toReplace.length(), "new text");

Maintenant, vous pouvez simplement créer une fonction pour votre commodité:

std::string replaceFirstOccurrence(
    std::string& s,
    const std::string& toReplace,
    const std::string& replaceWith)
{
    std::size_t pos = s.find(toReplace);
    if (pos == std::string::npos) return s;
    return s.replace(pos, toReplace.length(), replaceWith);
}
75
Mateen Ulhaq

Avons-nous vraiment besoin d'une bibliothèque Boost pour une tâche apparemment aussi simple?

Pour remplacer toutes les occurrences d'une sous-chaîne, utilisez cette fonction:

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 modified: " 
          << 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
24
Czarek Tomczak

Oui: replace_all est l'un des algorithmes de chaîne de renforcement:

Bien qu'il ne s'agisse pas d'une bibliothèque standard, la bibliothèque standard contient quelques éléments:

  1. Notation plus naturelle basée sur des plages plutôt que sur des paires d'itérateurs. Ceci est pratique car vous pouvez imbriquer des manipulations de chaîne (par exemple, replace_all imbriqué dans une trim). C'est un peu plus compliqué pour les fonctions de bibliothèque standard.
  2. Complétude. Ce n’est pas difficile d’être «meilleur»; la bibliothèque standard est assez spartiate. Par exemple, les algorithmes de chaîne de renforcement vous donnent un contrôle explicite sur la manière dont les manipulations de chaîne sont effectuées (c'est-à-dire à la place ou par copie).
23
phooji
#include <iostream>
#include <string>
using namespace std;

int main ()
{
    string str("one three two four");
    string str2("three");
    str.replace(str.find(str2),str2.length(),"five");
    cout << str << endl;
    return 0;
}

Sortie

one five two four
10
Mark Tolonen

comme certains disent boost :: replace_all

voici un exemple factice:

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

    std::string path("file.gz");
    boost::replace_all(path, ".gz", ".Zip");
7
Sylvain Rochette

Pas exactement cela, mais std::string a beaucoup de replace fonctions surchargées.

Passez par ce lien pour voir les explications de chacun, avec des exemples d'utilisation.

En outre, il existe plusieurs versions de string::find (fonctions répertoriées ci-dessous) que vous pouvez utiliser avec string::replace.

  • trouver 
  • retrouver 
  • find_first_of
  • find_last_of
  • find_first_not_of
  • find_last_not_of

Notez également qu'il existe plusieurs versions des fonctions replace disponibles à partir de <algorithm> que vous pouvez également utiliser (au lieu de string::replace):

  • remplacer 
  • remplacer_si 
  • replace_copy 
  • replace_copy_if 
2
Nawaz
// replaced text will be in buffer.
void Replace(char* buffer, const char* source, const char* oldStr,  const char* newStr)
{
    if(buffer==NULL || source == NULL || oldStr == NULL || newStr == NULL) return; 

    int slen = strlen(source);
    int olen = strlen(oldStr);
    int nlen = strlen(newStr);

    if(olen>slen) return;
    int ix=0;

    for(int i=0;i<slen;i++)
    {
        if(oldStr[0] == source[i])
        {
            bool found = true;
            for(int j=1;j<olen;j++)
            {
                if(source[i+j]!=oldStr[j])
                {
                    found = false;
                    break;
                }
            }

            if(found)
            {
                for(int j=0;j<nlen;j++)
                    buffer[ix++] = newStr[j];

                i+=(olen-1);
            }
            else
            {
                buffer[ix++] = source[i];
            }
        }
        else
        {
            buffer[ix++] = source[i];
        }
    }
}
2
Bayram AKGÜL

Voici la version que j'ai écrite qui remplace toutes les occurrences de la chaîne cible dans une chaîne donnée. Fonctionne sur tout type de chaîne.

template <typename T, typename U>
T &replace (
          T &str, 
    const U &from, 
    const U &to)
{
    size_t pos;
    size_t offset = 0;
    const size_t increment = to.size();

    while ((pos = str.find(from, offset)) != T::npos)
    {
        str.replace(pos, from.size(), to);
        offset = pos + increment;
    }

    return str;
}

Exemple:

auto foo = "this is a test"s;
replace(foo, "is"s, "wis"s);
cout << foo;

Sortie:

thwis wis a test

Notez que même si la chaîne de recherche apparaît dans la chaîne de remplacement, cela fonctionne correctement.

0
anisoptera
void replace(char *str, char *strFnd, char *strRep)
{
    for (int i = 0; i < strlen(str); i++)
    {
        int npos = -1, j, k;
        if (str[i] == strFnd[0])
        {
            for (j = 1, k = i+1; j < strlen(strFnd); j++)
                if (str[k++] != strFnd[j])
                    break;
            npos = i;
        }
        if (npos != -1)
            for (j = 0, k = npos; j < strlen(strRep); j++)
                str[k++] = strRep[j];
    }

}

int main()
{
    char pst1[] = "There is a wrong message";
    char pfnd[] = "wrong";
    char prep[] = "right";

    cout << "\nintial:" << pst1;

    replace(pst1, pfnd, prep);

    cout << "\nfinal : " << pst1;
    return 0;
}
0
snb