FAQ - Umwandlung nach std::string und zurück

Dravere

Lies die FAQ!
http://www.c-plusplus.net/forum/39488

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

Nexus

Viel wichtiger als boost::lexical_cast sind die direkten Stringumwandlungsfunktionen der C++0x-Standardbibliothek, also std::to_string() , std::stoi() und Co. Siehe hier

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

314159265358979

Ich kenne den Artikel. Wie schon im anderen Thread erwähnt finde ich ihn bestenfalls mangelhaft.

314159265358979

Wollte ich noch hinzufügen, Nexus.

Dravere

Sorry, mein Beitrag vorher war etwas zu scharf und nicht gut genug. War noch am bearbeiten, da habe ich versehentlich auf Absenden geklickt. Und kurz darauf wurde er versehentlich von einem verwirrten Mod (;)) in die FAQ verschoben, wodurch ich nicht mehr editieren konnte

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

Nexus

Falls man den FAQ-Artikel verbessern will, schlage ich vor, std::strstream (deprecated) sowie die C-Möglichkeiten nicht mehr zu erwähnen. Allenfalls könnte man letztere in der C-FAQ auflisten.

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.

314159265358979

Das war genau mein Vorschlag bezüglich des Inhalts @ Nexus

314159265358979

no_comment schrieb:

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.

CStoll

Der Ansatz sieht schonmal recht brauchbar aus, allerdings läuft zumindest das Beispiel mit den selbstdefinierten IO-Operatoren über's Ziel hinaus. Selbst wenn du mit dem alten FAQ-Beitrag inhaltlich nicht zufrieden bist, könntest du zumindest die grundlegende Struktur übernehmen.

Nexus

Ich schreib sonst mal einen Entwurf.

Nexus

Hier wäre der Entwurf. Ich habe die Konvertierungen von und zu Strings jeweils zusammengefasst, damit die Ähnlichkeit deutlicher wird. Weiterführende Themen wie Fehlerbehandlung oder zusätzliche Parameter von stoi() etc. habe ich der Einfachheit halber weggelassen. Ich wäre froh um Rückmeldungen und allfällige Verbesserungen.

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);
}

314159265358979

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.

volkard

314159265358979 schrieb:

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.

314159265358979

Meinst du das erst oder zynisch?

Ki

Dann kann man auch gleich ein Mercurial-Repository aufsetzen.

volkard

314159265358979 schrieb:

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.

otze

volkard schrieb:

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?

Finde Nexus Vorschlag schon richtig gut. Ich hab mal versucht, den Text ein bisschen kompakter zu schreiben. Der Code ist identisch außer den öffnenden geschweiften Klammern um jeweils eine Zeile zu sparen.

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);
}

Crap, doch noch ein paar Schnitzer drin.

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.