Comment remplacer toutes les occurrences d'un caractère avec deux personnages en utilisant std::string?

La réponse est non... il n'est pas "facile" si vous voulez dire un one-liner déjà fournis par la bibliothèque standard. Cependant, il n'est pas difficile à mettre en œuvre cette fonction.

Tout d'abord, je pense que, probablement, vous aurez également besoin de remplacer \ avec \\ et autres caractères spéciaux. Dans ce cas, à l'aide de la replaceAll de mise en œuvre donnés par ildjarn va être ennuyeux (vous aurez besoin de remplacer la même chaîne à plusieurs reprises).

À mon avis il y a beaucoup de cas de la chaîne de transformation, où rien ne vaut l'aide d'un explicite char * approche. Dans ce cas précis, cependant, probablement à l'aide d'un index est une bonne chose:

std::string escape(const std::string& s)
{
    int n = s.size(), wp = 0;
    std::vector<char> result(n*2);
    for (int i=0; i<n; i++)
    {
        if (s[i] == '/' || s[i] == '\\')
            result[wp++] = '\\';
        result[wp++] = s[i];
    }
    return std::string(&result[0], &result[wp]);
}

L'idée de base est de se déplacer sur la chaîne et l'ajout d'un supplément \ caractère avant tout caractère spécial (ci-dessus j'ai juste géré / et \, mais vous voyez l'idée).
Le résultat est connu pour être au maximum de 2*n de longueur, donc je préallouer en faisant tout le traitement de O(n) (le replaceAll approche continue de bouger le reste de la corde à droite, rendant O(n^2)).
Même pour de courtes chaînes de caractères comme "this is a test with /slashes/that should be /escaped/" la fonction ci-dessus est sur mon PC le plus performant (1,3 x en vitesse), même si l'appel de replaceAll juste une fois et la manipulation au lieu de deux caractères spéciaux dans escape.

Note également que cette fonction retourne naturellement une chaîne distincte au lieu de modifier la corde en place (OMI une meilleure interface) et dans le moment de la comparaison, j'ai dû créer une chaîne de caractères pour chaque appel, de sorte que les résultats sont même déplacé vers l'égalité en raison de l'ajout de la constante de temps.

Le au-dessus de lecture/écriture approche peut également être facilement étendu aux plus complexes, des substitutions (par exemple, le remplacement de > avec > ou des caractères non imprimable gamme avec %xx encodage) en conservant une bonne efficacité pour les grandes chaînes de caractères (un seul passage).

std::string::remplacez

J'ai extrapolé sur la question, pour faire une streaming la mise en œuvre d'permet d'échapper à une variété de personnages.

Streaming prend vraiment le biscuit pour les grands volumes[1], parce que vous obtiendrez dans la fragmentation du segment/la performance de l'enfer autrement. Aussi, cela permet d'échapper les chaînes stockées dans tout type de source, comme les exemples ne montrent

Voir en Direct Sur Coliru

#include <iostream>
#include <iterator>
#include <set>
#include <sstream>
#include <string>
template <class _II, class _OI>
static _OI escapeSomeChars(const _II inIt, const _II endIt, _OI outIt)
{
for (_II it=inIt; it!=endIt; ++it)
switch (*it)
{
case '\0': outIt++ = '\\'; outIt++ = '0'; break;
case '\n': outIt++ = '\\'; outIt++ = 'n'; break;
case '\\': 
case '"' : 
case '$' : 
case '/' : outIt++ = '\\';
default  : outIt++ = *it;
}
return outIt;
}
static std::string escapeSomeChars(const std::string& input)
{
std::ostringstream os;
escapeSomeChars(input.begin(), input.end(), std::ostream_iterator<char>(os));
return os.str();
}
namespace /*anon*/ {
struct rawchar {   //helper - see e.g. http://bytes.com/topic/c/answers/436124-copy-istream_iterator-question
char _c; rawchar(char c=0) : _c(c) {} 
operator const char&() const { return _c; }
friend std::istream& operator>>(std::istream& is, rawchar& out) { return is.get(out._c); }
};
}
int main()
{
static const char data[] = "\"I will \\$one day \\have \\all \\\\my slash\\es escaped, much \\like\\ in the source!\n\"";
//use the overload for std::string
std::cout << escapeSomeChars(data);
std::cout << std::endl;
//streaming in & out:
std::istringstream is(data);
escapeSomeChars(std::istream_iterator<rawchar>(is), std::istream_iterator<rawchar>(), std::ostream_iterator<char>(std::cout));
std::cout << std::endl;
//but you don't need an istream, you can use any STL iterator range
escapeSomeChars(data, data+sizeof(data)/sizeof(data[0]), std::ostream_iterator<char>(std::cout));
std::cout << std::endl;
//but any source and target will do:
std::string asstring(data);
std::set<char> chars(asstring.begin(), asstring.end());
asstring.clear();
escapeSomeChars(chars.begin(), chars.end(), std::back_inserter(asstring));
std::cout << "Unique characters in data: '" << asstring << "', but properly escaped!" << std::endl;
return 0;
}

J'ai choisi un interrupteur, car il sera optimisé par le compilateur. Pour des ensembles dynamiques de escapable personnages, je préfère une sorte de recherche (un vecteur avec des std::find ferait, bien que pour les grands ensembles d'un std::set de set::trouver deviendrait le meilleur choix).

Espère que cette aide

[1] voir, par exemple, cette belle bug j'ai récemment rencontré: GParted: Simplifié cleanup_cursor() de la mise en œuvre