L'équivalent C++ de StringBuffer/StringBuilder ?

Question

Existe-t-il une classe de la bibliothèque de modèles standard C++ qui offre une fonctionnalité efficace de concaténation de chaînes de caractères, similaire à la classe C# StringBuilder ou de Java StringBuffer ?

Answer 1

La méthode C++ consiste à utiliser std::stringstream ou simplement des concaténations de chaînes de caractères. Les chaînes C++ étant mutables, les considérations de performance de la concaténation sont moins importantes.

en ce qui concerne le formatage, vous pouvez effectuer le même formatage sur un flux, mais d'une manière différente, similaire à cout . ou vous pouvez utiliser un foncteur fortement typé qui encapsule ceci et fournit une interface de type String.Format, par exemple. boost::format

Answer 2

Le site std::string.append n'est pas une bonne option car elle n'accepte pas de nombreux types de données. Une alternative plus utile est d'utiliser std::stringstream comme ça :

#include <sstream>
// ...

std::stringstream ss;

//put arbitrary formatted data into the stream
ss << 4.5 << ", " << 4 << " whatever";

//convert the stream buffer into a string
std::string str = ss.str();

Answer 3

NOTE : cette réponse a fait l'objet d'une certaine attention récemment. Je ne la préconise pas comme solution (c'est une solution que j'ai vue dans le passé, avant la STL). Il s'agit d'une approche intéressante qui ne devrait être appliquée qu'à partir de std::string ou std::stringstream si après avoir profilé votre code vous découvrez que cela apporte une amélioration.

J'utilise normalement soit std::string ou std::stringstream . Je n'ai jamais eu de problèmes avec ceux-ci. Normalement, je réserve d'abord un peu de place si je connais la taille approximative de la corde à l'avance.

J'ai vu d'autres personnes fabriquer leur propre constructeur de cordes optimisé dans un passé lointain.

class StringBuilder {
private:
    std::string main;
    std::string scratch;

    const std::string::size_type ScratchSize = 1024;  // or some other arbitrary number

public:
    StringBuilder & append(const std::string & str) {
        scratch.append(str);
        if (scratch.size() > ScratchSize) {
            main.append(scratch);
            scratch.resize(0);
        }
        return *this;
    }

    const std::string & str() {
        if (scratch.size() > 0) {
            main.append(scratch);
            scratch.resize(0);
        }
        return main;
    }
};

Il utilise deux cordes : une pour la majorité de la corde et l'autre comme zone de grattage pour concaténer des cordes courtes. Il optimise les ajouts en regroupant les opérations d'ajouts courts dans une petite chaîne, puis en l'ajoutant à la chaîne principale, ce qui réduit le nombre de réaffectations nécessaires sur la chaîne principale lorsqu'elle devient plus grande.

Je n'ai pas eu besoin de cette astuce avec std::string ou std::stringstream . Je pense que c'était utilisé avec une bibliothèque de chaînes de caractères tierce avant std::string, c'était il y a longtemps. Si vous adoptez une telle stratégie, commencez par profiler votre application.

Answer 4

std::string est l'équivalent C++ : il est mutable.

Answer 5

Vous pouvez utiliser .append() pour simplement concaténer des chaînes de caractères.

std::string s = "string1";
s.append("string2");

Je pense que tu pourrais même être capable de le faire :

std::string s = "string1";
s += "string2";

Quant aux opérations de formatage de l'interface C# StringBuilder Je crois que snprintf (ou sprintf si vous voulez prendre le risque d'écrire un code bogué ;-) ) dans un tableau de caractères et le reconvertir en chaîne de caractères est à peu près la seule option.