# string to int



## Thomasio (22. August 2006)

Ich brauche eine ganz kurze Konvertierung von std::string nach int
Alle Lösungen die ich im Web gefunden habe sind recht umständlich, weil immer alle Möglichkeiten berücksichtigt werden, wie z.B. wenn der string keine Zahl ist, oder ausser der Zahl noch etwas anderes beinhaltet

In meinem Fall kann ich absolut sicher sein, dass im string immer eine Zahl zwischen 0 und 25 steht und sonst gar nichts
Wie kann ich in diesem Fall am schnellsten zu folgendem Ergebnis kommen?

std::string myString = "17";
int Zahl = intval(myString);   // So kurz sollte es sein, nur halt auch funktionieren

und wenn wir gerade dabei sind, wenn ich das mal habe, brauche ich es kurz danach andersrum, da hätte ich zumindest einen Lösungsansatz, über konvertieren zu char und dann ausrechnen, suche aber auch da nach einer schnelleren Lösung, falls möglich

int Zahl = 17;
std:string myString(Zahl);   // oder so ähnlich


----------



## SPT (22. August 2006)

Hallo,

hilft dir das evtl. weiter ?

http://www.xon.de/x1/x1ref/index.html?html_atoi.htm


----------



## Thomasio (22. August 2006)

nicht wirklich, oder anders gesagt, das ist, was ich schon als Lösungsansatz habe,
itoa und atoi funktionieren prima von char* to int und umgekehrt, aber dabei muss ich meinen std::string zuerst in char* konvertieren, und genau den Schritt würde ich mir gerne sparen, sofern das irgendwie möglich ist


----------



## MCoder (22. August 2006)

Du könntest das mit einem Stringstream erledigen:

```
#include <string>
#include <sstream>

// String -> Int

std::string myString = "17";

std::stringstream sstr(myString);
int Zahl;
sstr >> Zahl;
```


```
#include <string>
#include <sstream>

// Int -> String

int Zahl = 17;

std::stringstream sstr;
sstr << Zahl;
std::string myString = sstr.str();
```
Gruß
MCoder


----------



## Thomasio (22. August 2006)

danke, werde mal versuchen welche der beiden Lösungen schneller läuft,
falls jemand einen noch schnelleren Weg kennt, bitte melden


----------



## GABehnke (22. August 2006)

Hmm,

vielleicht habe ich es nicht richtig verstanden,
aber was soll den noch schneller sein als

int Zahl = intval(myString.c_str()); 

Gruß
Gerhard


----------



## MCoder (22. August 2006)

@Gerhard: Das "intval" muss man halt erst noch kreieren. Eine solche Funktion gibt's (glaube ich) bei PHP, aber nicht bei C/C++.

Gruß
MCoder


----------



## GABehnke (22. August 2006)

Ups,

recht hast Du !
Ich meinte ja auch
nt Zahl = atoi(myString.c_str()); 

Gruß
Gerhard


----------



## Thomasio (22. August 2006)

ach je, hab ich mich wieder als Anfänger entlarvt, logisch, geht in 1 Schritt beides auf einmal

int Zahl = atoi(myString.c_str()); // kürzer gehts wirklich nimmer

und wie dann andersrum?

std:string myString(itoa(Zahl));   // geht das?


----------



## MCoder (22. August 2006)

Wenn, dann eher so: 
	
	
	



```
itoa(nZahl, (char *)mystring.c_str(), 10);
```

Wenn man allerdings C++ programmiert, sollte man meiner Meinung nach aber auf atoi, itoa & Co. verzichten und konsequent mit der STL arbeiten und da wären die stringstreams die entsprechende Lösung.

Gruß
MCoder


----------



## rook (23. August 2006)

MCoder hat gesagt.:
			
		

> ...Wenn man allerdings C++ programmiert, sollte man meiner Meinung nach aber auf atoi, itoa & Co. verzichten...



und warum das? nur weil es aus C zeiten is? ^^


----------



## MCoder (24. August 2006)

Die STL ist besser und vor allem sicher als viele Funktionen C-Library. Zum Beispiel *itoa* ist eine potentiell gefährliche Funktion, da die hier hier benötigten Buffer immer Kandidaten für Pufferüberläufe sind. Mit der STL geht man solchen Problemen aus dem Weg.

Gruß
MCoder


----------



## rook (24. August 2006)

nunja... das du sagst das sie BESSER ist.. langt mir nicht 
ich persönlich habe die funktion itoa noch nie genutzt... aber atoi... un ich hab nich die geringste ahnung warum diese funktion probleme machen soll :>

außerdem weiss ich garnich was STL is :suspekt: 
ich benutz vielen alten C kram und es fuzzt wunderbar... und vorallem schnell genug


----------



## MCoder (25. August 2006)

STL ist die Abkürzung für "Standard Template Library", es ist also die Standardbibliothek für C++. 
BESSER bedeutet mehr Möglichkeiten und einfachere Programmierung, etwa bei Strings oder dynamischen Datenstrukturen (vector, map list). Das wird sicher bei der sehr einfachen Anwendung in diesem Thread nicht so augenfällig.
Abgesehen davon passt die STL aufgrund ihrer Architektur (z.B. konsequent objektorientiert) hervorragend zu C++ und ich halte es für guten Programmierstil, damit zur arbeiten.

Und warum z.B. itoa (wie übrigens alle Funktionen mit char-Buffern) gefährlich ist, sollte folgendes Beispiel hinreichend erklären:

```
char buffer[3];
itoa(100000, buffer, 10);
```

Gruß
MCoder


----------



## rook (25. August 2006)

nunja, man sollte wissen was man programmiert 
danke für die kurze erleuterung auch wenns ein wenig offtopic war... sry


----------



## Mark (25. August 2006)

Hi rook!

Ich hoffe, nicht alle Deine 151 Beiträge - habe nur die letzten fünfzig gesehen  - sind so:
Bitte achte bzgl. Deiner durchgehenden Kleinschreibung auf die Netiquette. Danke 

Liebe Grüße,
Mark.


----------



## chasser (28. August 2006)

geht auch so (wenn man itoa nicht verwenden will):

CString sMeins;
int iZahl=1;

sMeins.Format("%d", iZahl);
//sMeins ist "1"


----------



## deepthroat (28. August 2006)

Hi.





			
				chasser hat gesagt.:
			
		

> geht auch so (wenn man itoa nicht verwenden will):
> 
> CString sMeins;
> int iZahl=1;
> ...


Das geht aber nur wenn man Visual C++ benutzt. Und verwende doch bitte die Code Tags ([c]...[/c] bzw. [code=cpp]...[/code]) für C bzw. C++ Code.

Gruß


----------



## vfl_freak (20. August 2008)

@deepthroat

kurze Zwischenfrage:



> verwende doch bitte die Code Tags (
> 
> 
> 
> ...



Wo finde ich denn bitte diese Tags Habe hier nur die Raute, was zu QUOTE führt ...
Oder müsste ich das jeweils von Hand umschreiben 

Danke und Gruß
Klaus


----------



## deepthroat (21. August 2008)

vfl_freak hat gesagt.:


> Wo finde ich denn bitte diese Tags Habe hier nur die Raute, was zu QUOTE führt ...
> Oder müsste ich das jeweils von Hand umschreiben


Also ich schreib's immer per Hand. Keine Ahnung ob es da auch eine alternative Methode gibt...

Gruß


----------



## vfl_freak (21. August 2008)

Moin,
schade - aber trotzdem Danke!
Gruß
Klaus


----------



## pepsi_gx (9. Juli 2009)

MCoder hat gesagt.:


> ```
> char buffer[3];
> itoa(100000, buffer, 10);
> ```


Könntest du an deinem Bespiel noch bisschen klarer erklären, warum das "gefährlich" ist?
(Ich verstehe das Bsp zwar, aber die Gefahr verstehe ich nicht ganz)


----------



## vfl_freak (9. Juli 2009)

Moin,

ganz einfach, weil Du so Deinen Speicher kaputt schriebst!

Auszug aus der Hilfe zu "itoa":


> The _itoa function convert the digits of the given value argument to a null-terminated character string and stores the result in string.



_buffer_ ist hier nur 3 Zeichen lang ist; 100000 sind in hex aber auch schon 3 Byte und dann PLUS '\0'. Passt also nicht!

Gruß
Klaus


----------



## pepsi_gx (9. Juli 2009)

vfl_freak hat gesagt.:


> _buffer_ ist hier nur 3 Zeichen lang ist; 100000 sind in hex aber auch schon 3 Byte und dann PLUS '\0'. Passt also nicht!
> 
> Gruß
> Klaus


interessant, vielleicht eine dumme Frage noch::-(
Es ist mir schon klar, so was macht den Speicher kaputt, aber was kann es noch führen, wenn man nen Speicher kaputt schreibt?


----------



## vfl_freak (9. Juli 2009)

Moin,

oha, das ein gaaaaanz weites Thema mit Dutzenden von Möglichkeiten!

Im Prinzip immer dann, wenn der Speicher anders beschrieben wird als allokiert, dann gibt es (oder besser: kann es) Probleme geben.

Im Beispiel hier ist ja so: es wird ein Byte mehr geschrieben, als für _*buffer*_ allokiert ist. Nun kann dieses nächste Byte zufällig unbelegt sein (ergo: es ist zunächst nicht kritisch). Wenn aber dieses Byte das erste Byte einer völlig anderen Variable ist, kann auf diese schon nicht mehr zugegriffen werden
und es knallt (resp. liefert ggf. Blödsinn).

Wenn ich andersrum über den allokierten Bereich rausschreibe und dieser Teil wird danach von einer anderen Variable wieder überschrieben (da das System ja glaubt, der Speicher sei unbelegt) dann ist Deine erste Variable _*buffer*_ kaputt.

Die jeweiligen Auaswirkungen bemerkt man jedoch u. U. erst "Stunden" später, wenn man wieder auf den jew. Bereich zugreift! Und wenn es dann zu einem scheinbar unkontrollierten Absturz kommt, dann such' mal die Ursache dafür ..... 

[EDIT] Greift man diese Bereiche bis Programmende nie wieder zu, fällt der Fehler nicht mal auf ....

gruß
Klaus


----------

