Wie ersetzt man alle Vorkommen eines Zeichens in einer Zeichenfolge?

Question 1

Was ist der effektive Weg, um alle Vorkommen eines Zeichens durch ein anderes Zeichen in zu ersetzen std::string?

Question 2

std::string enthält keine solche Funktion, aber Sie könnten eigenständig verwenden replace Funktion ab algorithm Header.

#include <algorithm>
#include <string>

void some_func() {
  std::string s = "example string";
  std::replace( s.begin(), s.end(), 'x', 'y'); // replace all 'x' to 'y'
}

Question 3

Im Mittelpunkt steht die Frage character Ersatz, aber da ich diese Seite sehr nützlich fand (insbesondere Konrads Bemerkung), möchte ich diese allgemeinere Implementierung teilen, die es ermöglicht, damit umzugehen substrings auch:

std::string ReplaceAll(std::string str, const std::string& from, const std::string& to) {
    size_t start_pos = 0;
    while((start_pos = str.find(from, start_pos)) != std::string::npos) {
        str.replace(start_pos, from.length(), to);
        start_pos += to.length(); // Handles case where 'to' is a substring of 'from'
    }
    return str;
}

Verwendungszweck:

std::cout << ReplaceAll(string("Number Of Beans"), std::string(" "), std::string("_")) << std::endl;
std::cout << ReplaceAll(string("ghghjghugtghty"), std::string("gh"), std::string("X")) << std::endl;
std::cout << ReplaceAll(string("ghghjghugtghty"), std::string("gh"), std::string("h")) << std::endl;

Ausgänge:

Number_Of_Beans

XXjXugtXty

hhhhhhhhhhhhhhhhhhhhhhhhhhhhhck

BEARBEITEN:

Das oben Gesagte kann besser umgesetzt werden, falls Sie Leistungen betreffen, indem Sie nichts zurücksenden (void) und die Änderungen direkt an der Zeichenfolge vornehmen str als Argument angegeben, bestanden nach Adresse anstatt nach Wert. Dies würde ein nutzloses und kostspieliges Kopieren der ursprünglichen Zeichenfolge vermeiden, während das Ergebnis zurückgegeben wird. Ihr Anruf, dann…

Code:

static inline void ReplaceAll2(std::string &str, const std::string& from, const std::string& to)
{
    // Same inner code...
    // No return statement
}

Hoffe, das wird für einige andere hilfreich sein …

Question 4

Ich dachte, ich würde in die werfen Boost-Lösung auch:

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

// in place
std::string in_place = "blah#blah";
boost::replace_all(in_place, "#", "@");

// copy
const std::string input = "blah#blah";
std::string output = boost::replace_all_copy(input, "#", "@");

Question 5

Stellen Sie sich einen großen binären Blob vor, in dem alle 0x00-Bytes durch “\1\x30” und alle 0x01-Bytes durch “\1\x31” ersetzt werden sollen, da das Transportprotokoll keine \0-Bytes zulässt.

In Fällen, in denen:

der ersetzende und der zu ersetzende String haben unterschiedliche Längen,

Es gibt viele Vorkommen der zu ersetzenden Zeichenfolge innerhalb der Quellzeichenfolge und
die Quellzeichenfolge ist groß,

die bereitgestellten Lösungen können nicht angewendet werden (weil sie nur einzelne Zeichen ersetzen) oder haben ein Performance-Problem, weil sie string::replace mehrmals aufrufen würden, was immer wieder Kopien der Größe des Blobs erzeugt. (Ich kenne die Boost-Lösung nicht, vielleicht ist es aus dieser Perspektive in Ordnung)

Dieser geht alle Vorkommen im Quellstring ab und baut den neuen String Stück für Stück auf Einmal:

void replaceAll(std::string& source, const std::string& from, const std::string& to)
{
    std::string newString;
    newString.reserve(source.length());  // avoids a few memory allocations

    std::string::size_type lastPos = 0;
    std::string::size_type findPos;

    while(std::string::npos != (findPos = source.find(from, lastPos)))
    {
        newString.append(source, lastPos, findPos - lastPos);
        newString += to;
        lastPos = findPos + from.length();
    }

    // Care for the rest after last occurrence
    newString += source.substr(lastPos);

    source.swap(newString);
}

Question 6

Ein einfaches Suchen und Ersetzen für ein einzelnes Zeichen würde etwa so aussehen:

s.replace(s.find("x"), 1, "y")

Um dies für die gesamte Saite zu tun, wäre es am einfachsten, bis zu Ihrer zu loopen s.find beginnt zurückzukehren npos. Ich nehme an, Sie könnten auch fangen range_error um die Schleife zu verlassen, aber das ist irgendwie hässlich.

Question 7

Wenn Sie mehr als ein einzelnes Zeichen ersetzen möchten und nur damit zu tun haben std::string, dann würde dieses Snippet funktionieren und sNeedle in sHaystack durch sReplace ersetzen, und sNeedle und sReplace müssen nicht dieselbe Größe haben. Diese Routine verwendet die While-Schleife, um alle Vorkommen zu ersetzen, und nicht nur das erste, das von links nach rechts gefunden wird.

while(sHaystack.find(sNeedle) != std::string::npos) {
  sHaystack.replace(sHaystack.find(sNeedle),sNeedle.size(),sReplace);
}

Question 8

Der Vollständigkeit halber, hier ist, wie man es mit macht std::regex.

#include <regex>
#include <string>

int main()
{
    const std::string s = "example string";
    const std::string r = std::regex_replace(s, std::regex("x"), "y");
}