Habe mich gerade gefragt, was wohl schneller (besser) sein würde, wenn man einen grösseren String aus mehreren anderen Strings zusammen setzen möchte.

#include <string>
#include <sstream>

// a)
std::string foo()
{
    std::stringstream Stream;

    Stream << "bli bla blu" << get_string() << "blu bla";

    Stream << get_another_string();

    Stream << get_a_very_long_string();

    // usw.

    return Stream.str();
}

// b)
std::string foo()
{
    std::string String;

    String += "bli bla blu";
    String += get_string();
    String += "blu bla";

    String += get_another_string();

    String += get_a_very_long_string();

    // usw.

    return String;
}

// c) ?

Ich tendiere eigentlich zu a) nur wegen dem praktischen her. Weil man kann da auch gleich normale Zahlen mit reinnehmen oder irgendwelche locales und facets verändern. Aber gibt es auch einen Unterschied bei der Geschwindigkeit?

Grüssli

a.) hat die bessere performance!

Hast du das ausgiebig getestet? Mit welchem Compiler, welcher Implementation der Standardbibliothek, welchen Optimierungseinstellungen?

@Dravere: Ich denke nicht, dass du dir bei sowas schon Gedanken um die Performance machen solltest, eher um Lesbarkeit und Erweiterbarkeit. Performance wird bei solchen Designdetails erst wichtig, wenn dein Profiler dir sagt, dass das Programm viel zeit in der Funktion verbringt - und die Funktion sieht nicht danach aus, es sei denn du machst in dem Programm hauptsächlich Stringmanipulationen.

Vom Aspekt der Leserlichkeit her sehen beide Ansätze sich ja recht ähnlich. Was das Erweitern angeht sieht der erste besser aus, da es einfach ist, beispielsweise auch Zahlen etc. in den Stream zu schicken, wenn sowas später mal dazukommen sollte (auch wenns nicht geplant ist, könnte es ja trotzdem passieren).

die Frage ist doch, wo geht der Riesenstring hin, wenn er fertig ist. Da ich nicht annehme, dass der weiter bearbeitet wird, sondern irgendwann ausgegeben wird (Datei, Konsole, Socket, usw.), ist es doch besser, die Funktionen get_another_string() nach get_another_string( std::ostream& output ) zu ändern, und einen streambuf'er zu kreieren und darunter zu hängen, der die Zeichen gleich da hin schreibt, wo sie hinsollen - ohne jeden Umweg.

Gruß
Werner

a.) hat die bessere performance!

Ist quatsch, was ich geschrieben habe.
Ist auch nicht diffrenziert.
Und es ist nicht mal getestet...

Sorry und Gruss
Simon

@Werner,
Das erscheint mir allerdings noch eine gute Idee zu sein. Allerdings würde ich es wenn schon anders machen:

#include <string>
#include <ostream>

std::ostream& foo(std::ostream& OutputStream)
{
    OutputStream << "bli bla blu" << get_string() << "blu bla";

    OutputStream << get_another_string();

    OutputStream << get_a_very_long_string();

    // usw.

    return OutputStream;
}

// Die get_xxx_string Funktionen sehen wahrscheinlich sowieso so aus:
const std::string& get_xxx_string();

Grüssli

// Die get_xxx_string Funktionen sehen wahrscheinlich sowieso so aus:
const std::string& get_xxx_string();

.. wie ist die Implementierung in der Funktion - mit was wird der jeweilige String gefüllt?

Dravere schrieb:

// Die get_xxx_string Funktionen sehen wahrscheinlich sowieso so aus:
const std::string& get_xxx_string();

.. wie ist die Implementierung in der Funktion - mit was wird der jeweilige String gefüllt?

Ok, ich hätte vielleicht schreiben sollen:

Wenn der String schon existiert:

const std::string& get_xxx_string();

Wenn der String noch konstruiert werden muss:

std::ostream& get_xxx_string(std::ostream& OutputStream);

Die Frage nach der Geschwindigkeit bleibt aber immer noch offen. Weiss da keiner etwas dazu?

Grüssli

Teste es doch. profiler + ein paar Millionen Durchläufe...

Hast du vielleicht auch gleich einen Vorschlag für einen guten Profiler? Da ich die eigentlich nie verwende, kenne ich mich auch nicht so aus, was es gibt, welche gut sind und ob es auch welche gibt, die gratis sind.

Deshalb frage ich ja auch, da vielleicht das jemand schon weiss oder es jemand mit Profiler Erfahrungen auch interessiert

Grüssli

Fellhuhn schrieb:

Teste es doch. profiler + ein paar Millionen Durchläufe...

Hast du vielleicht auch gleich einen Vorschlag für einen guten Profiler? Da ich die eigentlich nie verwende, kenne ich mich auch nicht so aus, was es gibt, welche gut sind und ob es auch welche gibt, die gratis sind.

Deshalb frage ich ja auch, da vielleicht das jemand schon weiss oder es jemand mit Profiler Erfahrungen auch interessiert

Grüssli

Kommt drauf an was du verwendest, für VS kann ich dir von Compuware den DevPartner empfehlen.

Kommt drauf an was du verwendest, für VS kann ich dir von Compuware den DevPartner empfehlen.

Du machst deinem Namen alle Ehre. Sind ja nur etwas über 1'000€, kein Problem.
Ich bin zwar wissbegierig, aber nicht leichtsinnig

@Fellhuhn,
Hmmm, na mal schauen, wann ich Zeit habe mich nochmals in die Kommandozeilen Compiler einzuarbeiten. Bin von IDEs (VS2005) verwöhnt

Sonstige Vorschläge?

Grüssli

Edit:
Zudem gibts von Compuware soviel ich weiss eine Community Edition (gratis) die für die meisten Fälle ausreichend ist.

lolz_ausgeloggt schrieb:

Kommt drauf an was du verwendest, für VS kann ich dir von Compuware den DevPartner empfehlen.

Du machst deinem Namen alle Ehre. Sind ja nur etwas über 1'000€, kein Problem.
Ich bin zwar wissbegierig, aber nicht leichtsinnig

@Fellhuhn,
Hmmm, na mal schauen, wann ich Zeit habe mich nochmals in die Kommandozeilen Compiler einzuarbeiten. Bin von IDEs (VS2005) verwöhnt

Sonstige Vorschläge?

Grüssli

Du sollst dir ja auch nicht die Suite kaufen, sondern den Profiler von denen benutzen, den gibts kostenlos. Nennt sich Code Analyzer oder so ähnlich.

Die VS2005 Team Edition hat auch einen eingebauten Profiler.
Sehr komfortabel finde ich.

Das ist wohl in VS2005 Professional nicht vorhanden?

(D)Evil schrieb:

AMD CodeAnalyst ...

Ist aber nur für AMDs. Hab aber Intel ^^"

simon.gysi schrieb:

Zudem gibts von Compuware soviel ich weiss eine Community Edition (gratis) die für die meisten Fälle ausreichend ist.

Ich habe jetzt sicher die Seite 5 Mal angeschaut und habe es immer überlesen. Erst als ich die letzte Vorschau gemacht habe und dann den neuen Beitrag von lolz gelesen habe, bin ich noch ein sechstes Mal schauen gegangen und hab es gefunden.
hwups

Falls Leute drauf stossen:
http://www.compuware.com/products/devpartner/profiler/default.asp?cid=701000000004ej0AAA&focus=&productfocus=&source=Web+-+Evaluation+Request&offering=DevPartner&productfamily=DevPartner&desc=The+DevPartner+Community+Profiler+Edition+is+a+product+download+that+offers+customers+and+prospects+a+high-level+view+of+the+performance+profiling+capabilities+of+DevPartner+Studio+Professional+Edition.&trk=200601-74
(Was für eine URL ^^)

Grüssli

std::string functionOne()
{
    std::string strReturn;

    strReturn += "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
    strReturn += "ABCDEFGHIJKLMNOPQRSTUVWXYZ";

    strReturn += "0987654321";
    strReturn += "0987654321";

    strReturn += "1234567890";
    strReturn += "1234567890";

    return strReturn;
}

std::string functionTwo()
{
    std::stringstream StringStream;

    StringStream << "ABCDEFGHIJKLMNOPQRSTUVWXYZ" << "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
    StringStream << "0987654321" << "0987654321";
    StringStream << "1234567890" << "1234567890";

    return StringStream.str();
}

std::ostream& functionThree(std::ostream& OutputStream)
{
    OutputStream << "ABCDEFGHIJKLMNOPQRSTUVWXYZ" << "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
    OutputStream << "0987654321" << "0987654321";
    OutputStream << "1234567890" << "1234567890";

    return OutputStream;
}

void testOne()
{
    for(int i = 0; i < 100000; ++i)
    { functionOne(); }
}

void testTwo()
{
    for(int i = 0; i < 100000; ++i)
    { functionTwo(); }
}

void testThree()
{
    std::stringstream StringStream;

    for(int i = 0; i < 100000; ++i)
    { functionThree(StringStream); }
}

int main()
{
    testOne();

    testTwo();

    testThree();

    return 0;
}

Ohne Optimierungen:
functionOne hat im Durchschnitt 2.2 Mikrosekunden benötigt.
functionTwo hat im Durchschnitt 16.5 Mikrosekunden benötigt.
functionThree hat im Durchschnitt 15.8 Mikrosekunden benötigt.

Mit Optimierungen:
functionOne hat im Durchschnitt 2.5 Mirkosekunden benötigt.
functionTwo hat im Durchschnitt 7.4 Mirkosekunden benötigt.
functionThree hat im Durchschnitt 6.8 Mikrosekunden benötigt.

Vor allem hätte ich nicht gedacht, dass das += von std::string so viel schneller ist als die Streams. Aber wenn ich so weiter überlege, macht das wohl durchaus Sinn, weil beim Stream die ganze Zeit noch die locales checks dazukommen und anderes. Trotzdem hätte ich nicht gedacht, dass der Unterschied so extrem ist.

Grüssli

void functionOne(std::string& dest)
{
    dest = "";
    dest += "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
    dest += "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
    dest += "0987654321";
    dest += "0987654321";
    dest += "1234567890";
    dest += "1234567890";
}

void testOne()
{
    std::string result;

    for (std::size_t i(0); i < 100000; ++i)
        functionOne(result);
}

Bevor wieder was kommt - joar, bei 2005 prof. wahrscheinlich auch - aber die Team Edition gibts (oder gab es zumindest mal) für 180 Tage kostenlos auf der ms-site zum download... Ich hab mal von einem gehört, dass man in dem image nur 2 *.dll`s verändern muss (also runterladen und ersetzen) und es eine Vollversion wird - aber dazu kann ich dir natürlich nix sagen ;o)

Ich kann dir auch nur VS empfehlen...

bb ^^