Umwandlungen über boost::lexical_cast

Am einfachsten ist es, lexical_cast aus boost zu verwenden. Boost ist eine riesige Bibliothek an Funktionen und Klassen, die einem das Leben etwas leichter machen, jeder C++ Programmierer sollte sie haben. Boost kann kostenlos unter www.boost.org heruntergeladen werden.

Eingebaute Typen wie int können wir damit ohne weiteren Aufwand umwandeln:

#include <boost/lexical_cast.hpp>
#include <string>

int main()
{
    int als_int = 42;

    std::string als_string = boost::lexical_cast<std::string>(als_int); // "42"
    int wieder_als_int = boost::lexical_cast<int>(als_string); // 42
}

Sollte eine Umwandlung nicht gelingen, versucht man z.B. aus "C++" eine Zahl zu machen, wirft lexical_cast eine bad_lexical_cast Exception.

Mit lexical_cast können wir auch eigene Typen umwandeln:

#include <boost/lexical_cast.hpp>
#include <ostream>
#include <istream>
#include <iomanip>
#include <string>

struct person
{
	std::string name;
	unsigned alter;

	// Wenn wir einen std::string in einen eigenen Typen casten wollen, brauchen wir einen Standardkonstruktor.
	person()
	{}

	person(std::string name, unsigned alter)
		: name(name)
		, alter(alter)
	{}
};

// Das casten nach string geschieht ganz einfach über den operator <<, den wir ganz normal schreiben.
std::ostream& operator << (std::ostream& os, const person& p)
{
	// Wir trennen Name und Alter durch ein Leerzeichen, damit das Einlesen etwas leichter wird.
	return os << p.name << ' ' << p.alter;
}

// Beim Einlesen müssen wir prüfen, ob Leerzeichen ausgelassen werden oder nicht.
std::istream& operator >> (std::istream& is, person& p)
{
	// Wir holen uns die Formatflags, in denen steht, ob Leerzeichen ausgelassen werden.
	std::ios_base::fmtflags flags = is.flags();

	// Wenn Leerzeichen nicht ausgelassen werden, aktivieren wir das.
	if(!(flags & std::ios::skipws))
		is >> std::skipws;

	// Jetzt können wir ganz normal einlesen.
	is >> p.name >> p.alter;

	// Zu sauberer Programmierung gehört auch, dass wir den alten Status wiederherstellen.
	is.flags(flags);

	return is;
}

int main()
{
	person als_person("Marc++us", 40); // Unser Foren-Administrator

	std::string als_string = boost::lexical_cast<std::string>(als_person); // Umwandlung nach std::string
	person wieder_als_person = boost::lexical_cast<person>(als_string); // Umwandlung zurück in eine Person
}

Umwandlungen über std::stringstream
Mit std::stringstream können wir auch umwandeln, um genau zu sein macht boost::lexical_cast genau das - nur etwas komfortabler - für uns.

Hier kommt noch was, ich fahr jetzt nach Hause. Feedback wäre schon mal super

lol, perfekt. Jemand verfasst einen Artikel für die FAQ, welche er selbst gar nicht liest :p
Man könnte sich höchstens mal überlegen, dem FAQ Artikel einen Zusatz mit boost::lexical_cast zu geben. Ist meiner Meinung nach fragwürdig, schliesslich ist Boost immer noch "nur" ein Framework.

Grüssli

Davon abgesehen ist dein Code viel zu komplex. Operatorüberladung und Stream-Flags gehören nicht in einen Artikel über String-Umwandlung.

Naja, also:
Wie gesagt, wir haben schon eine FAQ Artikel für std::string nach Zahl und zurück. Da sieht man auch gut, wie so ein FAQ Artikel aussehen muss. Kurz und einfach.

Zusätzlich haben wir noch mindestens zwei Artikel, wo das Überladen von den Stream-Operatoren vorkommt:
Überladen von Operatoren in C++ (Teil 1)
Ein- und Ausgabe in C++ - IO-Streams

Ich würde da wirklich etwas massiv kurzes Schreiben und auf den FAQ-Artikel sowie die beiden Magazin-Artikel verweisen.

Grüssli

Also nur noch:

• C++98: std::stringstream
• C++0x: std::to_string() & Co.
• Boost: boost::lexical_cast

Aber liest überhaupt jemals jemand die FAQ? Vor allem gibt es etwa 50 andere unwichtige Threads in diesem Bereich, zwischen denen sowas nur untergeht. Dann gibt es noch den Thread "die meistgestellten Fragen". Klar muss man irgendwo anfangen, aber wenn man die FAQ verbessert, müsste man am besten ein paar einzelne gute Beiträge behalten und den Rest komplett löschen. Vor allem hat eine Forendiskussion nichts in einem FAQ-Thread zu suchen.

person(std::string name, unsigned alter)
: name(name)
, alter(alter)
{}

*stirnklatsch*
So benennt ein selbsternannter Profi-C++ler also seine member und parameter.

person(std::string name, unsigned alter)
: name(name)
, alter(alter)
{}

*stirnklatsch*
So benennt ein selbsternannter Profi-C++ler also seine member und parameter.

Und was gibts daran auszusetzen? Weiters habe ich mich nirgens als C++ Profi bezeichnet.

In C++ gibt es verschiedenste Möglichkeiten, Konvertierungen zwischen Zeichenketten (z.B. std::string ) und arithmetischen Typen (z.B. int , double ) vorzunehmen. Im Folgenden sollen die wichtigsten davon erklärt werden.

1. Standard-Konvertierungsfunktionen

Standardbibliotheken, die den C++11-Standard unterstützen, bieten diverse überladene Funktionen im Header <string> an, welche eine direkte Umwandlung zwischen Strings und eingebauten Typen unterstützen. Die Konvertierung von arithmetischen Typen zu Strings erfolgt mit den folgenden überladenen Funktionen:

• to_string() zur Konvertierung in std::string
• to_wstring() zur Konvertierung in std::wstring

In umgekehrter Richtung existieren folgende Funktionen, die jeweils für std::string - und std::wstring -Parameter überladen sind:

• stoi() für int
• stol() für long
• stoll() für long long
• stoul() für unsigned long
• stoull() für unsigned long long
• stof() für float
• stod() für double
• stold() für long double

Die Anwendung sieht folgendermassen aus:

#include <string>

int main()
{
    // Zahl nach String
    double      a = 4.72;
    std::string x = std::to_string(a);

    // String nach Zahl
    std::string y = "5.67";
    double      b = std::stod(y);
}

2. Stringstreams

Eine weitere Möglichkeit zur Umwandlung bietet die Klasse std::stringstream . Falls nur Konvertierungen in eine Richtung erforderlich sind, kann std::ostringstream für Output- und std::istringstream für Input-Streams verwendet werden. Für Wide-Strings ( std::wstring ) existieren entsprechende Klassen mit vorangestelltem "w", z.B. std::wostringstream .

Streams zahlen sich gegenüber den direkten Umwandlungsfunktionen vor allem dann aus, wenn mehrere Werte verkettet werden oder spezielle Stream-Funktionalität (wie Formatflags) erforderlich ist. Die Handhabung ist ähnlich zu std::cout und std::cin , zum Setzen und Auslesen des Strings können die überladenen Methoden str() verwendet werden.

#include <sstream>
#include <string>

int main()
{
    double a = 4.72;
    int    b = 88;

    // Output-Stream: Zahlen zu String zusammenfügen
    std::ostringstream oss;
    oss << a << ' ' << b;
    std::string x = oss.str();

    // Input-Stream: Zahlen aus String extrahieren
    std::istringstream iss;
    iss.str("5.67 12"); // oder direkt Konstruktor verwenden
    iss >> a >> b;
}

3. Boost.LexicalCast

Boost ist eine Sammlung von C++-Bibliotheken und enthält unter anderem Funktionalität zur Umwandlung zwischen arithmetischen Datentypen und Zeichenketten. Dazu dient das Funktionstemplate boost::lexical_cast<T> , wobei T den Zieltypen der Konvertierung bezeichnet. Die Syntax ist analog zu den C++-Cast-Operatoren wie z.B. static_cast<T> .

Gegenüber der ersten Variante besteht hier der Vorteil, dass keine C++11-Unterstützung notwendig ist. Im Weiteren ist die Syntax für alle Umwandlungen einheitlich, was generische Programmierung vereinfacht.

#include <boost/lexical_cast.hpp>
#include <string>

int main()
{
    // Zahl nach String
    double      a = 4.72;
    std::string x = boost::lexical_cast<std::string>(a);

    // String nach Zahl
    std::string y = "5.67";
    double      b = boost::lexical_cast<double>(y);
}

Finde ich gut, allerdings sollte zumindest bei boost::lexical_cast auf die Fehlerbehandlung kurz eingegangen werden und bei Streams auf die Referenz verwiesen werden, meiner Meinung nach.

Ich schlage vor, Du kopierst und änderst (machst debei die Änderungen kenntlich). Der nächste kopiert und ändert weiter. Und wenn alle Protagonisten damit zufrieden sind, wird's wohl so gut sein, daß es (unter Streichung aller Änderungsvermerke) in die FAQ gehört.

Meinst du das erst oder zynisch?

Ich glaube an das Gute.
Ich glaube daran, daß der Artikel schon fast fertig ist und binnen Tagen gegen eine nahezu perfekte Fassung konvergieren wird.

Ich glaube daran, daß der Artikel schon fast fertig ist und binnen Tagen gegen eine nahezu perfekte Fassung konvergieren wird.

ist der Konvergenzradius denn groß genug? Und ist sicher, dass der Prozess eine ständig steigende Nutzenfunktion zu Folge hat? Gibt es vielleicht mehrere gute Lösungen mit suboptimalen Transienten dazwischen?

Hier einige Möglichkeiten, von int , double usw in std::string (bzw. std::wstring ) und umgekehrt zu konvertieren.

1. Standard-Konvertierungsfunktionen (nur C++0x, ab GCC 4.?.? oder Visual Studio 2010)

Im neuen Standard gibt es im Header <string> die Funktionen to_string() und to_wstring() zur Konvertierung von nach std::string bzw. std::wstring .
Daneben für std::wstring und std::wstring zu den arithmetischen Typen:

• stoi() für int
• stol() für long
• stoll() für long long
• stoul() für unsigned long
• stoull() für unsigned long long
• stof() für float
• stod() für double
• stold() für long double

Anwendung:

#include <string>

int main() {
    // Zahl nach String
    double      a = 4.72;
    std::string x = std::to_string(a);

    // String nach Zahl
    std::string y = "5.67";
    double      b = std::stod(y);
}

2. Stringstreams

Wer C++x0 nicht nutzt, kann std::stringstream nehmen. Falls nur Konvertierungen in eine Richtung erforderlich sind, kann std::ostringstream für Output- und std::istringstream für Input-Streams verwendet werden. Für Wide-Strings ( std::wstring ) analog mit vorangestelltem "w", z.B. std::wostringstream .
Hier lassen sich auch leicht mehrere Werte verkettet werden oder z.B. Formatflags einsetzen. Die Handhabung ist ähnlich zu std::cout und std::cin . Zum Setzen und Auslesen des Strings können die überladenen Methoden str() verwendet werden.

#include <sstream>
#include <string>

int main() {
    double a = 4.72;
    int    b = 88;

    // Output-Stream: Zahlen zu String zusammenfügen
    std::ostringstream oss;
    oss << a << ' ' << b;
    std::string x = oss.str();

    // Input-Stream: Zahlen aus String extrahieren
    std::istringstream iss;
    iss.str("5.67 12"); // oder direkt Konstruktor verwenden
    iss >> a >> b;
}

3. Boost.LexicalCast

Boost ist eine beliebte Sammlung von C++-Bibliotheken und enthält unter anderem das Funktionstemplate boost::lexical_cast<T> mit T als Zieltyp der Konvertierung. Die Syntax ist analog zu den C++-Cast-Operatoren wie z.B. static_cast<T> . Die einheitliche Syntax für Umwandlungen vereinfacht generische Programmierung.

#include <boost/lexical_cast.hpp>
#include <string>

int main() {
    // Zahl nach String
    double      a = 4.72;
    std::string x = boost::lexical_cast<std::string>(a);

    // String nach Zahl
    std::string y = "5.67";
    double      b = boost::lexical_cast<double>(y);
}

Die letzten zwei Sätze Die Syntax ist analog zu den C++-Cast-Operatoren wie z.B. static_cast<T> und gut geeignet für generische Programmierung.

Just my 2 cents...

Und was den Code anbelangt: Öffnende und schliessende Klammern auf der gleichen Höhe finde ich um einiges übersichtlicher. Ist ja nicht so, dass wir hier unbedingt die eine Zeile sparen müssten.

Bezüglich Locales: Wäre eine Möglichkeit. Dann würde ich aber auch auf Fehlerbehandlung eingehen. Ich habe solche Dinge wie erwähnt weggelassen, da der Artikel primär eine Übersicht über die verschiedenen Wege zur String-Konvertierung geben soll. Besonders Anfänger sind vielleicht froh, wenn sie gerade die wichtigen Daten auf einen Blick haben. Man könnte aber am Schluss eine Liste mit weiterführenden Links (z.B. über Streams) anfügen.