Ich habe einige Leute gehört, die sich Sorgen über den Operator "+" in std :: string und verschiedene Problemumgehungen gemacht haben, um die Verkettung zu beschleunigen. Sind diese wirklich notwendig? Wenn ja, wie lassen sich Zeichenfolgen in C ++ am besten verketten?

Die zusätzliche Arbeit lohnt sich wahrscheinlich nicht, es sei denn, Sie brauchen wirklich wirklich Effizienz. Sie werden wahrscheinlich eine viel bessere Effizienz erzielen, wenn Sie stattdessen den Operator + = verwenden.

Nach diesem Haftungsausschluss werde ich Ihre eigentliche Frage beantworten ...

Die Effizienz der STL-Zeichenfolgenklasse hängt von der Implementierung der von Ihnen verwendeten STL ab.

Sie könnten Effizienz garantieren und mehr Kontrolle haben indem Sie die Verkettung manuell über die integrierten c-Funktionen durchführen.

Warum Operator + nicht effizient ist:

Schauen Sie sich diese Oberfläche an:

template <class charT, class traits, class Alloc>
basic_string<charT, traits, Alloc>
operator+(const basic_string<charT, traits, Alloc>& s1,
          const basic_string<charT, traits, Alloc>& s2)

Sie können sehen, dass nach jedem + ein neues Objekt zurückgegeben wird. Das bedeutet, dass jedes Mal ein neuer Puffer verwendet wird. Wenn Sie eine Menge zusätzlicher + Operationen ausführen, ist dies nicht effizient.

Warum Sie es effizienter machen können:

• Sie garantieren Effizienz, anstatt einem Delegierten zu vertrauen, dass er dies effizient für Sie erledigt
• Die Klasse std :: string weiß nichts über die maximale Größe Ihres Strings und auch nicht darüber, wie oft Sie mit ihm verketten werden. Möglicherweise verfügen Sie über dieses Wissen und können Dinge tun, die auf diesen Informationen basieren. Dies führt zu weniger Neuzuweisungen.
• Sie steuern die Puffer manuell, damit Sie sicher sein können, dass Sie nicht die gesamte Zeichenfolge in neue Puffer kopieren, wenn Sie dies nicht möchten.
• Sie können den Stapel für Ihre Puffer anstelle des viel effizienteren Heaps verwenden.
• Der Operator string + erstellt ein neues String-Objekt und gibt es unter Verwendung eines neuen Puffers zurück.

Überlegungen zur Umsetzung:

• Verfolgen Sie die Saitenlänge.
• Halten Sie einen Zeiger auf das Ende der Zeichenfolge und den Anfang oder nur auf den Anfang und verwenden Sie den Start + die Länge als Versatz, um das Ende der Zeichenfolge zu finden.
• Stellen Sie sicher, dass der Puffer, in dem Sie Ihre Zeichenfolge speichern, groß genug ist, damit Sie keine Daten neu zuweisen müssen
• Verwenden Sie strcpy anstelle von strcat, damit Sie nicht über die Länge der Zeichenfolge iterieren müssen, um das Ende der Zeichenfolge zu finden.

Seildatenstruktur:

Wenn Sie wirklich schnelle Verkettungen benötigen, sollten Sie eine Seildatenstruktur verwenden .

Reservieren Sie vorher Ihren endgültigen Speicherplatz und verwenden Sie dann die Append-Methode mit einem Puffer. Angenommen, Sie erwarten eine endgültige Zeichenfolgenlänge von 1 Million Zeichen:

std::string s;
s.reserve(1000000);

while (whatever)
{
  s.append(buf,len);
}

Ich würde mir darüber keine Sorgen machen. Wenn Sie dies in einer Schleife tun, weisen Zeichenfolgen immer Speicher zu, um Neuzuweisungen zu minimieren. Verwenden Sie dies nur operator+=in diesem Fall. Und wenn Sie es manuell tun, so etwas oder länger

a + " : " + c

Dann werden temporäre Dateien erstellt - auch wenn der Compiler einige Kopien von Rückgabewerten entfernen könnte. Dies liegt daran, dass in einem nacheinander aufgerufenen operator+Objekt nicht bekannt ist, ob der Referenzparameter auf ein benanntes Objekt oder ein von einem Unteraufruf zurückgegebenes temporäres Objekt verweist operator+. Ich würde mir lieber keine Sorgen machen, bevor ich nicht zuerst ein Profil erstellt habe. Aber nehmen wir ein Beispiel, um das zu zeigen. Wir führen zuerst Klammern ein, um die Bindung klar zu machen. Ich setze die Argumente direkt nach der Funktionsdeklaration, die der Klarheit halber verwendet wird. Darunter zeige ich, was der resultierende Ausdruck dann ist:

((a + " : ") + c) 
calls string operator+(string const&, char const*)(a, " : ")
  => (tmp1 + c)

In diesem Zusatz tmp1wurde nun der erste Aufruf von operator + mit den angezeigten Argumenten zurückgegeben. Wir gehen davon aus, dass der Compiler wirklich clever ist und die Rückgabewertkopie optimiert. Am Ende haben wir also eine neue Zeichenfolge, die die Verkettung von aund enthält " : ". Nun passiert dies:

(tmp1 + c)
calls string operator+(string const&, string const&)(tmp1, c)
  => tmp2 == <end result>

Vergleichen Sie das mit Folgendem:

std::string f = "hello";
(f + c)
calls string operator+(string const&, string const&)(f, c)
  => tmp1 == <end result>

Es verwendet dieselbe Funktion für eine temporäre und eine benannte Zeichenfolge! Der Compiler muss also das Argument in eine neue Zeichenfolge kopieren und an diese anhängen und aus dem Hauptteil von zurückgeben operator+. Es kann nicht die Erinnerung an eine temporäre nehmen und daran anhängen. Je größer der Ausdruck ist, desto mehr Kopien von Zeichenfolgen müssen erstellt werden.

Next Visual Studio und GCC unterstützen die Verschiebungssemantik von c ++ 1x (ergänzt die Kopiersemantik ) und die rvalue-Referenzen als experimentelle Ergänzung. Auf diese Weise können Sie herausfinden, ob der Parameter auf ein temporäres Element verweist oder nicht. Dies wird solche Ergänzungen erstaunlich schnell machen, da alle oben genannten in einer "Add-Pipeline" ohne Kopien enden werden.

Wenn sich herausstellt, dass es sich um einen Engpass handelt, können Sie dies dennoch tun

 std::string(a).append(" : ").append(c) ...

Die appendAufrufe hängen das Argument an *thisund geben dann einen Verweis auf sich selbst zurück. Dort wird also kein Provisorium kopiert. Alternativ operator+=kann das verwendet werden, aber Sie benötigen hässliche Klammern, um die Priorität festzulegen.

Für die meisten Anwendungen spielt es einfach keine Rolle. Schreiben Sie einfach Ihren Code, ohne zu wissen, wie genau der Operator + funktioniert, und nehmen Sie die Angelegenheit nur dann selbst in die Hand, wenn dies zu einem offensichtlichen Engpass wird.

Im Gegensatz zu .NET System.Strings, C ++ 's std :: strings sind wandelbar und können daher durch einfache Verkettung aufgebaut werden genauso schnell wie durch andere Methoden.

vielleicht stattdessen std :: stringstream?

Aber ich stimme dem Gefühl zu, dass Sie es wahrscheinlich nur wartbar und verständlich halten und dann profilieren sollten, um zu sehen, ob Sie wirklich Probleme haben.

In Imperfect C ++ präsentiert Matthew Wilson einen dynamischen Zeichenfolgenverketter, der die Länge der endgültigen Zeichenfolge vorberechnet, um nur eine Zuordnung zu erhalten, bevor alle Teile verkettet werden. Wir können auch einen statischen Verketter implementieren, indem wir mit Ausdrucksvorlagen spielen .

Diese Art von Idee wurde in der STLport std :: string-Implementierung implementiert - die aufgrund dieses präzisen Hacks nicht dem Standard entspricht.

std::string operator+ordnet eine neue Zeichenfolge zu und kopiert jedes Mal die beiden Operandenzeichenfolgen. viele Male wiederholen und es wird teuer, O (n).

std::string appendund operator+=auf der anderen Seite stößt die Kapazität um 50% jedes Mal , wenn die Zeichenfolge wachsen muss. Dies reduziert die Anzahl der Speicherzuweisungen und Kopiervorgänge erheblich, O (log n).

Für kleine Saiten spielt es keine Rolle. Wenn Sie große Zeichenfolgen haben, sollten Sie diese besser als Vektor oder in einer anderen Sammlung als Teile speichern. Und passen Sie Ihren Algorithmus an, um mit solchen Daten anstelle der einen großen Zeichenfolge zu arbeiten.

Ich bevorzuge std :: ostringstream für komplexe Verkettung.

Wie bei den meisten Dingen ist es einfacher, etwas nicht zu tun, als es zu tun.

Wenn Sie große Zeichenfolgen an eine GUI ausgeben möchten, kann es sein, dass alles, was Sie ausgeben, die Zeichenfolgen in Teilen besser verarbeiten kann als eine große Zeichenfolge (z. B. das Verketten von Text in einem Texteditor - normalerweise werden die Zeilen getrennt Strukturen).

Wenn Sie in eine Datei ausgeben möchten, streamen Sie die Daten, anstatt eine große Zeichenfolge zu erstellen und diese auszugeben.

Ich habe nie die Notwendigkeit gefunden, die Verkettung schneller zu machen, wenn ich unnötige Verkettung aus langsamem Code entfernt habe.

Wahrscheinlich die beste Leistung, wenn Sie Speicherplatz in der resultierenden Zeichenfolge vorab zuweisen (reservieren).

template<typename... Args>
std::string concat(Args const&... args)
{
    size_t len = 0;
    for (auto s : {args...})  len += strlen(s);

    std::string result;
    result.reserve(len);    // <--- preallocate result
    for (auto s : {args...})  result += s;
    return result;
}

Verwendung:

std::string merged = concat("This ", "is ", "a ", "test!");

Ein einfaches Array von Zeichen, das in einer Klasse gekapselt ist, die die Arraygröße und die Anzahl der zugewiesenen Bytes verfolgt, ist am schnellsten.

Der Trick besteht darin, zu Beginn nur eine große Zuordnung vorzunehmen.

beim

https://github.com/pedro-vicente/table-string

Benchmarks

Für Visual Studio 2015, x86-Debug-Build, wesentliche Verbesserung gegenüber C ++ std :: string.

| API                   | Seconds           
| ----------------------|----| 
| SDS                   | 19 |  
| std::string           | 11 |  
| std::string (reserve) | 9  |  
| table_str_t           | 1  |  

Sie können dies mit Speicherreservierungen für jedes Element versuchen:

namespace {
template<class C>
constexpr auto size(const C& c) -> decltype(c.size()) {
  return static_cast<std::size_t>(c.size());
}

constexpr std::size_t size(const char* string) {
  std::size_t size = 0;
  while (*(string + size) != '\0') {
    ++size;
  }
  return size;
}

template<class T, std::size_t N>
constexpr std::size_t size(const T (&)[N]) noexcept {
  return N;
}
}

template<typename... Args>
std::string concatStrings(Args&&... args) {
  auto s = (size(args) + ...);
  std::string result;
  result.reserve(s);
  return (result.append(std::forward<Args>(args)), ...);
}