string str = str2.at(2); -> Fehler

hallo

ich hab folgende funktion:

int str2int(string str)
{
	stringstream sstr;
	sstr<<str;
	int i;
	sstr>>i;
	return i;
}

diese funktion funktioniert auch z.B:

int x = str2int("2");

aber string.at(2) gibt char zurück statt string deswegen geht es leider nicht

string zahl="12345";
int x = str2int(zahl.at(2));
//x sollte jetzt 3 sein

das geht leider auch nicht:

int x = static_cast<int>(zahl.at(2));
//gibt 53 aus (ASCII-Code)
//oder
int x = str2int(zahl.at(2).c_str());
//der compiler kann das c_str() nicht dem string zahl zuordnen sonst würde
//es gehen

hat jemand eine idee wie ich das problem beheben könnte?
Danke

Braunstein

Hallo,

Man könnte das z.Bsp. so machen

int x = str2int(zahl.substr(2,1));

Desweitern würde ich den Parameter in deiner Funktion anders übergeben (konstante Referenz statt Kopie).

.filmor

Oder du überlädst einfach für char:

inline std::string str2int (char c)
{
    return str2int (std::string (&c));
}

Bin mir aber nicht sicher, ob das richtig ist, kompilieren und laufen tuts aber.

GPC

@.filmor:
Der Name ist unglücklich gewählt, da nicht wirklich ein string zu nem int gemacht wird, und was soll das &-Zeichen bei der Übergabe an die eigentliche Funktion? Die erwartet keinen Pointer.

Braunstein

Das nicht. std::string hat aber keinen Konstruktor für char, wohl aber für char*. Das sollte so aber nicht funktionieren da so kein gültiger String an den Konstruktor übergeben wird.

.filmor

Tuts aber ;). Übrigens habe nicht ich diesen Namen gewählt.

Braunstein

Tut es wirklich?
Wenn du so aus einem char ein char* machst, sollte eigentlich das abschließende Nullbyte fehlen.

.filmor

Schon klar, aber zumindest mit der Windows-Shell klappts. Bash dagegen gibt (wie es sich gehört) noch massig Müll aus.

camper

Braunstein schrieb:

Tut es wirklich?
Wenn du so aus einem char ein char* machst, sollte eigentlich das abschließende Nullbyte fehlen.

kommt auf die ABI an. wenn wir von 32-bit x86 architektur ausgehen, dann ist jedes argument, dass über den stack übergeben wird, ohnehin 32bit aligned. es ist durchaus denkbar, dass kleinere argumente zunächst auf 32-bit zero/sign-extended werden anstatt irgendwelche reste, die noch im register vorhanden sind, zu verwenden. das hat nat. keine auswirkungen darauf, dass dieser code UB produziert.

p.s. std::string hat zwar keinen konstruktor für char, dafür aber einen für char + std::size_t ...

CStoll

.filmor schrieb:

return str2int (std::string (&c));

Ich würde dort eher "std::string(1,c)" übergeben, der char*-Konstruktor dürfte dir sonst irgendwelchen Datenmüll in deinen String reinpacken (eine char-Variable ist nicht Null-terminiert).

string str = str2.at(2); -&gt; Fehler

string str = str2.at(2); -> Fehler