Wieso kann man in C++ keine Strings mit Ints verknüpfen?

Nimm boost::format.

Nexus

Badestrand schrieb:

Ich kann "der denker" aber schon verstehen. Ich denke, er hätte gerne sowas:
std::string s;
s << 10 << "Hallo " << setprecision(3) << 1.234567 << endl;

Kann man dazu den << Operator nicht überladen?

man könnte einfach immer auf stringstreams setzen! spricht da jetzt was dagegen oder nicht?
mir fällt jedenfalls nichts ein!

groovemaster

Bashar schrieb:

groovemaster schrieb:

'~' ist immerhin auch der Operator für bitweise Negierung.

Nein, das ist der unäre Operator.

Und nachts ist es kälter als draussen. Ob unär oder nicht ist bezugslos zu meiner Aussage. '~' ist und bleibt ein Operator.

Badestrand

Nexus schrieb:

Badestrand schrieb:
Ich kann "der denker" aber schon verstehen. Ich denke, er hätte gerne sowas:
std::string s;
s << 10 << "Hallo " << setprecision(3) << 1.234567 << endl;
Kann man dazu den << Operator nicht überladen?

Klar kann man das, will man aber nicht Es wäre halt schön (habe jetzt aber auch nicht alle Konsequenzen bedacht), wenn sowas im Standard-Krams wäre.

der streamer schrieb:

man könnte einfach immer auf stringstreams setzen! spricht da jetzt was dagegen oder nicht?
mir fällt jedenfalls nichts ein!

Ne, ist nicht praktikabel, einer der Gründe:

void foo( std::stringstream& s );

std::stringstream a("Hallo"), b("Welt");
foo( a + b ); //<- kompiliert nicht

lass mich mal überlegen..

void foo( std::string& s );

std::string a("Hallo"), b("Welt");
foo( a + b );

das wäre ja sonst das äquivalent dazu, ich erzeuge mir also einen temporären string aus a und b.
dann müsste doch theoretisch auch das hier funktionieren:

void foo( std::stringstream& s );

std::stringstream a("Hallo"), b("Welt");
foo( a.str() + b.str() );

Bashar

groovemaster schrieb:

Bashar schrieb:

groovemaster schrieb:

'~' ist immerhin auch der Operator für bitweise Negierung.

Nein, das ist der unäre Operator.

Und nachts ist es kälter als draussen. Ob unär oder nicht ist bezugslos zu meiner Aussage. '~' ist und bleibt ein Operator.

Aber du hast schon verstanden, was ich ausdrücken will?

Nexus

groovemaster schrieb:

Bashar schrieb:

groovemaster schrieb:

'~' ist immerhin auch der Operator für bitweise Negierung.

Nein, das ist der unäre Operator.

Und nachts ist es kälter als draussen. Ob unär oder nicht ist bezugslos zu meiner Aussage. '~' ist und bleibt ein Operator.

Bezugslos ist es nicht unbedingt, aber irrelevant. Ein Negationsoperator ist immer unär, gleich wie ! oder - (Vorzeichen). Das hat nichts damit zu tun, dass ~ bitweise wirkt. Unär bedeutet hier nur, dass der Operator nur einen Operand benötigt.

der streamer schrieb:

dann müsste doch theoretisch auch das hier funktionieren:
void foo( std::stringstream& s );

std::stringstream a("Hallo"), b("Welt");
foo( a.str() + b.str() );

Nein, da du der Funktion einen std::string übergibst. Der Parametertyp ist aber std::stringstream& .

Badestrand

der streamer schrieb:

dann müsste doch theoretisch auch das hier funktionieren:
void foo( std::stringstream& s );

std::stringstream a("Hallo"), b("Welt");
foo( a.str() + b.str() );

Das Argument von foo muss noch const sein, aber das meintest du ja wahrscheinlich auch. Ich krieg's dann aber nur so foo( std::stringstream( a.str() + b.str() ) ); hin, schön ist was anderes
Naja, aber sonst fällt mir kein Argument mehr ein gegen "immer stringstream". Hm.

Ja, das habe ich übersehen. Schön ist das wirklich nicht, aber dafür hat man paar andere Vorteile.

Simon2

[Naja . war bestimmt sowieso nur Trollerei ... aber da will ich mal nicht so sein, weil ich gerade gute Laune habe.]

Es nervt! schrieb:

...
Warum geht das nicht? ...

Vielleicht, weil ein int eben kein string ist ?
Ich bin ehrlich gesagt sehr froh, dass in C++ ein string ein string, ein int ein int und ein stream ein stream ist. Alles andere macht einen nämlich ganz schnell wahnsinnig (natürlich nicht, wenn man sowieso nur 20-Zeilen-Clickibunti-Programe schreibt)
...und erst Recht bin ich froh, dass weder string noch int eine Sonderrolle haben, sondern sich eben genauso verhalten wie andere Typen.

BTW: Geht das

str += val;

in Java wirklich ? Würde mich doch mangels "überladbarer" operatoren sehr wundern.

Gruß,

Simon2.

Nexus

Du hast Recht. Für Gleichberechtigung unter den Datentypen!

Gehört in Java ein String nicht zu den Grunddatentypen, für die überladene Operatoren bereits bestehen?

Badestrand schrieb:

void foo( std::stringstream& s );

std::stringstream a("Hallo"), b("Welt");
foo( a.str() + b.str() );

Das Argument von foo muss noch const sein[/quote]

wieso sollte es das müssen?

Badestrand

falsch schrieb:

Badestrand schrieb:
void foo( std::stringstream& s );
Das Argument von foo muss noch const sein
wieso sollte es das müssen?

Weil du sonst eine non-const-Referenz auf ein temporäres Objekt hättest, temporäre Objekte sind aber quasi nur zum Lesen und nicht zum Schreiben da..

void foo1( const int& a );
void foo2( int& a );

void kraks()
{
    foo1( 10 ); // Geht
    foo2( 10 ); // Geht nicht
}

Simon2

Nexus schrieb:

...Gehört in Java ein String nicht zu den Grunddatentypen, ...

Eben: Igittibäh !!
Spätestens, weil das mit "myInt" oder "myString" schon nicht mehr geht und auch nicht "gehbar gemacht" werden kann.

Gruß,

Simon2.

also bei mir geht beides (visual c++)

Badestrand

falsch schrieb:

also bei mir geht beides (visual c++)

Das ist bedenklich.. Welche Version? Und was passiert, wenn du in foo2 einen Wert zuweist?

Jetzt bin ich verwirrt:

void foo2( int& a )
{
	std::cout << a << std::endl;
}

void foo3( std::string& s)
{
	std::cout << s << std::endl;
}

int main()
{
    foo2(10); // geht nicht
    foo3(std::string("temp")); // geht
    return 0;
}

Ich sehe da nicht so den massiven Unterschied...

Badestrand

Beim Aufruf von foo3 wird ein temporäres std::string-Objekt vor dem Aufruf erzeugt; näheres kann dir jetzt auch nur noch camper oder irgendwer anderes Standard-vertrautes sagen..

Aber dann binde ich ja trotzdem ein temporäres Objekt an eine non-const referenz!