ZFX + Developia

BeRsErKeR hat geschrieben:

Code: Alles auswählen

string foo = "Extreeeeeeeeeeeeeeem lange Konkatenation";
foo += 123456.ToString();
foo += eineFunktion("blub");
...
print(foo);

MasterQ32 hat geschrieben:Wie stehts mit speichern der Literale (strings) in einer Variable + Format-Paramter?

FlorianB82 hat geschrieben:

MasterQ32 hat geschrieben:Wie stehts mit speichern der Literale (strings) in einer Variable + Format-Paramter?

Ich kenne mich nur in C++ gut aus, aber eventuell ist es ja auch in C# von Relevanz:

Ich versuche die sprintf()-Funktion zu meiden, da man einfach zu viele Fehler machen kann (falsche specifiers, falsche Parameteranzahl, falsche Puffergröße). Am angenehmsten finde ich, per std::sstream und dessen Operatoren den String zusammenzubauen - ganze ohne die genannten Fallstricke.

Aus Leserlichkeitsgründen einfache Konkatenationen durch sprintf()-Aufrufe austauschen zu wollen, empfinde ich persönlich eher als Schritt in die falsche Richtung.

MasterQ32 hat geschrieben:Wie stehts mit speichern der Literale (strings) in einer Variable + Format-Paramter?
Für C# (was es ja augenscheinlich ist) wäre das so:

Code: Alles auswählen

foo(string.Format(
    "Extreeeeeeeeeeeeeeem lange Konkatenation{0}{1}noch viel mehr Text{2}usw",
    123456,
    eineFunktion("blub"),
    undNochEineFunktion(x, y, z)));

Durch das Zeileneinrücken wird das ganze nicht so lang und durch den Format-Parameter richtig schön lesbar.
Außerdem ist ein .ToString() nicht nötig.

foo("Extreeeeeeeeeeeeeeem lange Konkatenation" +
    123456 +
    eineFunktion("blub") +
    "noch viel mehr Text" +
    undNochEineFunktion(x, y, z) +
    "usw");

foo("Extreeeeeeeeeeeeeeem lange Konkatenation" +
    123456 +
    eineFunktion("blub" + nochEinFunktionMitLangemNamen(123456) + "foobar" + foo("thereisalotmoretext" + "abc123" + someOtherFunc(x, y, z))) +
    "noch viel mehr Text" +
    undNochEineFunktion(x, y, z) +
    "usw");

MasterQ32 hat geschrieben:Der Vorteil ist, dass du deinen String einfach in ein Literal packst und fertig. Heißt, später steht da sowas:

Code: Alles auswählen

string sinnvollerName1 = eineFunktion(...);
foo(string.Format(
    fooFormatString, // Besserer Name hier einfügen
    123456,
    sinnvollerName1,
    undNochEineFunktion(x, y, z)));

So bleibt der Code immer bei max. einer Call-Verschachtelung. Muss man halt schauen, wie genau man das löst. Aber sag uns doch mal ein konkretes Beispiel, wo so ein langer Code anfällt, ich hab selten so lange Zeilen in meinem Code, auch für String-Konkatenation (für das man eigentlich einen StringBuilder nehmen sollte)

dot hat geschrieben:Stringkonkatenation ist imo der falsche Ansatz hier, was du eigentlich willst, ist ein stringstream:

Code: Alles auswählen

std::ostringstream msg;
msg << "Extreeeeeeeeeeeeeeem lange Konkatenation"
    << 123456
    << eineFunktion("blub")
    << "noch viel mehr Text"
    << undNochEineFunktion(x, y, z)
    << "usw";

Wesentlich effizienter und lässt sich auch beliebig in separate Statements aufbrechen. Eine Sache, auf die hier natürlich generell vergessen wird, ist Internationalisierung... ;)

BeRsErKeR hat geschrieben:

dot hat geschrieben:Stringkonkatenation ist imo der falsche Ansatz hier, was du eigentlich willst, ist ein stringstream:

Code: Alles auswählen

std::ostringstream msg;
msg << "Extreeeeeeeeeeeeeeem lange Konkatenation"
    << 123456
    << eineFunktion("blub")
    << "noch viel mehr Text"
    << undNochEineFunktion(x, y, z)
    << "usw";

Wesentlich effizienter und lässt sich auch beliebig in separate Statements aufbrechen. Eine Sache, auf die hier natürlich generell vergessen wird, ist Internationalisierung... ;)

Ein stringstream ist ja auch nichts anderes als die Stringkonkatenation in C#. Jedenfalls von der Funktionalität her und auch von der Codelänge. Auch in deinem Beispiel hast du ein Problem wenn z.B. eineFunktion wieder eine sehr lange Parameterliste aufweist bzw. einen Parameter schluckt, der wiederum zusammengebaut wird.

dot hat geschrieben:

BeRsErKeR hat geschrieben:

dot hat geschrieben:Stringkonkatenation ist imo der falsche Ansatz hier, was du eigentlich willst, ist ein stringstream:

Code: Alles auswählen

std::ostringstream msg;
msg << "Extreeeeeeeeeeeeeeem lange Konkatenation"
    << 123456
    << eineFunktion("blub")
    << "noch viel mehr Text"
    << undNochEineFunktion(x, y, z)
    << "usw";

Wesentlich effizienter und lässt sich auch beliebig in separate Statements aufbrechen. Eine Sache, auf die hier natürlich generell vergessen wird, ist Internationalisierung... ;)

Ein stringstream ist ja auch nichts anderes als die Stringkonkatenation in C#. Jedenfalls von der Funktionalität her und auch von der Codelänge. Auch in deinem Beispiel hast du ein Problem wenn z.B. eineFunktion wieder eine sehr lange Parameterliste aufweist bzw. einen Parameter schluckt, der wiederum zusammengebaut wird.

Ein stringstream ist etwas fundamental anderes als Stringkonkatenation, ganz besonders in C#, wo Strings immutable sind. Viel eher entspricht stringstream dem .NET StringBuilder.

Das Ganze lässt sich auch in weitere Funktionen aufspalten, man kann den stringstream ja beliebig herumreichen. Außerdem hat man natürlich die ganze Palette an Techniken inklusive I/O Manipulatoren und custom Streamoperatoren zur Verfügung...

EyDu hat geschrieben:String Formatting hat gegenüber einfacher Konkatenation oder Streams einige Vorteile. So steht der Formatstring im Fokus der Formatierung, so dass die Vorlage wie normaler Text gelesen werden kann. Wenn man etwas am Format umstellen kann, dann muss man sich nicht erst durch die ganzen Einzelteile kämpfen, sondern ändert einfach nur den String.

Ein weiterer Vorteil ist, dass die Reihenfolge der Parameter immer gleich bleiben kann. Diese muss nie geändert werden. Werden die Parameter im Formatstring mittels "{0}", "{1}" etc. referenziert (oder bei Manchen Sprachen auch über den Namen, was natürlich sehr praktisch ist), dann kann die Formatierung beliebig umgestellt werden. Aus "{0} + {1} = {2}" kann man dann problemlos auch "{2} = {0} + {1}" machen. Mit Konkatenation und Streams muss hingegen die ganze Anweisung umgestellt werden.

Im Vergleich zur Konkatenation kommt dann noch hinzu, dass die Konstruktion mittels String Formatting linear ist. Werden die Strings mittels + zusammengefügt, so ergibt sich schnell quadratische Laufzeit. Gut, bei kleinen Strings ist das meistens egal, da wird der Vorteil (am Ende bei der Laufzeit) durch das Parsen des Strings aufgehoben.

Und dann ist es natürlich noch ganz angenehm, dass die Formatierungsparameter direkt in den Formatstring eingebaut werden können. Mittels Konkatenation ist so etwas einfach nur hässlich, mit Streams mindestens aber anstrengend.

BeRsErKeR hat geschrieben:Wie schon gesagt. Es geht hier nicht darum ob ein String Formatting besser oder effizienter ist. Es geht hier einzig darum, wie man lange Codezeilen ausdrückt. Als Einzeiler, als Mehrzeiler mit Umbrüchen oder als Mehrzeiler mit Einzelzuweisungen. Wie gesagt kommt am besten mal weg von Strings. Denkt euch einfach eine lange Operation wie 132473284 + 2343324 - myvarname * foobar(123456, pow(2, 6000) + 284943854 - 99999999) + ... + einige_verschaltelungen_spaeter - ...

d = sqrt((x1 - x2)**2 + (y1 - y2)**2)
=>
a = x1 - x2
b = y1 - y2
d = sqrt(a**2 + b**2)

a*b + foo(2, bar(f, g, h), 42) + u*v
=>
a*b +
u*v +
foo(
    2,
    bar(
        f,
        g,
        h),
    42)

RedGuy hat geschrieben:Also mir geht es primär um Performanz, sekundär um die Lösung der Aufgabe.

RedGuy hat geschrieben:Niemals würde ich für einen solchen Zweck temporäre Variablen oder String-Konkatenationen einsetzen!

dot hat geschrieben:

RedGuy hat geschrieben:Niemals würde ich für einen solchen Zweck temporäre Variablen oder String-Konkatenationen einsetzen!

Deine Lösung verwendet aber Stringkonkatenation und erzeugt temporäre Objekte... ;)

RedGuy hat geschrieben:@Alexander Kornrumpf:
was genau verstehst du nicht ?