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

camper

hgfdsa schrieb:

Warum geht das bei stringstream aber nicht bei string?

DrakoXP täuscht sich hier. Eine solche Überladung führt nicht zu Mehrdeutigkeiten, wenn das Argument 0 ist, da habe ich auch nicht aufgepasst.

DrakoXP

stimmt, weil int naheliegender ist als char*.

das Problem entstht, wenn man statt int long, short, char oder long long verwendet,
weil die mit char* gleichwertig sind.

Nexus

DrakoXP schrieb:

stimmt, weil int naheliegender ist als char*.

das Problem entstht, wenn man statt int long, short, char oder long long verwendet,
weil die mit char* gleichwertig sind.

Wieso sollen diese Typen gleichwertig mit char* sein, int aber nicht? Die wären wohl eher mit int gleichwertig; denn wenn man z.b. folgendes schreibt, weiss der Compiler nicht, ob es ein short, long, char oder was auch immer ist; ich denke, er nimmt einfach int an... Aber char* wird er wohl als letztes annehmen, oder irre ich mich?

0;

camper schrieb:

hgfdsa schrieb:

Warum geht das bei stringstream aber nicht bei string?

DrakoXP täuscht sich hier. Eine solche Überladung führt nicht zu Mehrdeutigkeiten, wenn das Argument 0 ist, da habe ich auch nicht aufgepasst.

std::string& operator+(std::string& str, int i)
{
    std::stringstream ss;
    ss << i;
    str += ss.str();
    return str;
}

int main(int argc, char** argv) {

	int i = 0;
	std::stringstream stream;
	stream << "NULL = ";
	stream << i; //geht
	stream << 0; //geht

	std::cout<<stream.str();

	std::string strNull = "Null = ";
	strNull += i; //geht
	strNull += 0; //geht nicht

	return 0;
}

Mit Visual Studio 2008 kompiliert das letzte aber nicht

error C2593: 'Operator +=' ist mehrdeutig

Warum?

SAn

There is a hell in C++ with this NULL pointer!

I think NULL should be forbidden in new standard and it should be used something like null<char *> for zero pointers of type char * .

For example, in Pascal the zero pointer is nil which is not equvalent to 0.

.filmor

0 ist ein Spezialfall. Das ist ein int, aber genauso weit von den anderen Ganzzahltypen entfernt wie von Zeigertypen. Das gilt nur für die 0, mit anderen Ganzzahlkonstanten funktioniert das nicht (unter anderem auch nicht mit 0l, aber mit 0u).

SAn

hgfdsa schrieb:

std::string& operator+(std::string& str, int i)
{
    std::stringstream ss;
    ss << i;
    str += ss.str();
    return str;
}

operator+ modifies the first argument? This is not good. It should be std::string& const str .

Nexus

SAn schrieb:

It should be std::string& const str .

Du meinst wohl / you certainly mean:

std::string const& str

Aber ich würde sowieso schreiben / However, I would write:

const std::string &str

Soll ich eigentlich deutsch oder englisch schreiben? Hab mal beides gemacht

Wieso kann man bei einem Stringstream Ints reinpacken, bei einem String aber nicht?
Und wieso haben Stringstreams diese Fähigkeit bekommen, nicht aber Strings?

Keine Sau braucht Stringsstreams! (Eigentlich nur, um den Pfusch an std::string zu umfrickeln!)

Nexus

Skandal! schrieb:

Wieso kann man bei einem Stringstream Ints reinpacken, bei einem String aber nicht?
Und wieso haben Stringstreams diese Fähigkeit bekommen, nicht aber Strings?

Keine Sau braucht Stringsstreams! (Eigentlich nur, um den Pfusch an std::string zu umfrickeln!)

StringStreams sind ziemlich nützlich. Nur weil du sie nicht genug kennst, heisst das nicht, dass sie niemand braucht.

std::string wurde für Zeichenketten und Operationen wie Teilstrings, Aneinanderreihungen, Zeichensuche etc. konzipiert. Soviel zum Pfusch.
Die Anhängung von beliebigen Datentypen würde den (sonst schon grossen) Umfang der string-Klasse noch stark erweitern. Das wäre überflüssig, weil man die Verbindung mit irgendwelchen Typen kaum braucht. Wenn doch, nimmt man dafür eben Streams. Was spricht dagegen?

Ausserdem ist es jedem überlassen, seine eigene Stringklasse zu schreiben oder von std::string zu erben . C++ bietet einem ja diese Möglichkeit.

Aneinanderreihungen... aber wieso nicht auch Aneinanderreihungen von ints!!
Die Begründung, dass es weak typing wäre, kann ich grad noch so akzeptieren.
Trotzdem ist es im Alltag sehr hinderlich.

Und ich muss sagen, es wäre für mich als Benutzer der Sprache weniger Overhead,
wenn die String-Klasse ints aufnehmen könnte, anstatt noch eine weitere Klasse
zu instanzieren und mit zusätzlichen Code eben das zu erreichen.

Aber warum ist es dann bei stringstream nicht mehrdeutig? Ist da 0 kein Spezialfall?

PS:

Nexus schrieb:

oder von std::string zu erben. C++ bietet einem ja diese Möglichkeit.

Nein http://www.c-plusplus.net/forum/viewtopic-var-t-is-211691.html

SAn

Streams were specially designed to convert data types to/from string representations using locales and formats. For example, if you want 34 to be translated into string as "0034" or "0x22" then what you will do with string?

P.S. I can read German.
P.P.S: It will be good to have string and stringsream objects merged together

BorisDieKlinge

std::string test =" HAllo"

test+=5; //<== sieht doch behindert aus

lieber

test & 5;

Badestrand

BorisDieKlinge schrieb:

test & 5;

Das ist ja wohl völlig abwegig. Dann eher lieber spezielle Concetation-Operatoren wie in D (ich glaube '~'). Das alles löst aber nicht das von SAn angesprochene Problem mit der Formatierung, da käme dann evtl ein Weg wie in C# in Frage:

double d;
std::string s = d.toString(5) + "aha...";

Dort kann man die Formatierungsoptionen noch mit angeben, soweit ich das richtig in Erinnerung hab (hier halt 5 Nachkommastellen).

Bashar

BorisDieKlinge schrieb:

lieber
test & 5;

Du hast wohl Sehnsucht nach Visual Basic?

Nexus

SAn schrieb:

Streams were specially designed to convert data types to/from string representations using locales and formats. For example, if you want 34 to be translated into string as "0034" or "0x22" then what you will do with string?
[...]
P.P.S: It will be good to have string and stringsream objects merged together

Dem kann ich zustimmen. Und wie gesagt, std::string wurde nicht für solche Fälle entwickelt. Irgendwo muss es auch seine Grenzen haben. Sonst könnte man geradesogut noch Funktionen in std::string einbauen, die FileStreams und Grafikausgaben erlauben. Wieso nicht gleich eine Sprachausgabe?
Und nochmals: Was spricht gegen die Benutzung von StringStreams?

BorisDieKlinge schrieb:

lieber 

[cpp]test & 5;

Noch lieber:

test &= 5;          // wenn es gleich an test darangehängt werden soll
test & 5;           // wenn nur der Ausdruck eine Aneinanderreihung ergibt.

Ich find jedoch ehrlich gesagt weder & noch + einen schönen Operator dafür... Ob die Tilde besser ist, darüber kann man sich streiten, spielt ja schlussendlich keine so grosse Rolle.

hgfdsa schrieb:

PS:

Nexus schrieb:

oder von std::string zu erben. C++ bietet einem ja diese Möglichkeit.

Nein http://www.c-plusplus.net/forum/viewtopic-var-t-is-211691.html

In dem Thread ist Ableitung von std::string gerade ziemlich umstritten - es ist keine gute Idee, ok, aber prinzipiell möglich. Und sonst nimmt man einen std::string als Member seiner eigenen Klasse. Ich will jetzt aber nicht die Diskussion vom anderen Thread hier weiterführen...

std::string& operator<<(std::string& str, int i)
{
    std::stringstream ss;
    ss << i;
	str += ss.str();
    return str;
}

int main(int argc, char** argv) {

	int i = 0;
	std::stringstream stream;
	stream << "NULL = ";
	stream << i; //geht
	stream << 0; //geht

	std::cout<<stream.str();

	std::string strNull = "Null = ";
	strNull << i; //geht
	strNull << 0; //geht

	std::cout << strNull;

	return 0;
}

So gehts.
Ich weiß das stringstream für sowas da ist, weils auch ein bisschen effizenter bei mehreren Verknüpfungen ist.

Was mich mehr interessieren würde ist, warum 0 bei += ein Spezialfall ist.

Bitte was, Stringstreams sind nur für solche Konvertierungen gedacht? Die Konvertierungsmöglichkeiten sind doch eher ein Nebeneffekt! Ich würde auch die Lösung aus C# gut heißen. Integrierte Datentypen sind Objekte und haben Methoden um sich selbst zu konverieren.

darthdespotism

Und wo bitte ist dann der Unterschied zwischen

double d;
std::string str;
str += d.to_double();

und

double d;
std::string str;
str += lexical_cast<std::string>(d);

?