Skip navigation

Da ‘toString’ keine Standardfunktion innerhalb von C++ ist, man muss seine eigene implementieren um die vergleichbare Funktionalität zu erreichen. Eine der Möglichkeiten wäre Templates zu benutzen.

template<typename T>
std::string stringify(T const& input)
{
	std::ostringstream output;
	if(!(output<<input))
	{
		// HANDLE ERROR HERE
	}
	return output.str();
}

Du kannst auch deine eigene ‘stringTo…’ implementieren. Benutz den folgenden Quellkoden.

template<typename T>
void destringify_intern(std::string const& input, T& output)
{
	std::istringstream stream(input);
	if(!(stream>>output))
	{
		// HANDLE ERROR HERE
	}
}

Ich habe den ‘intern’ Suffix benutzt, da man eine Wrapper-Funktion schreiben kann, die etwas zurück gibst statt nur Referenzen zu nutzen. Oder um das Overhead, das mit einem extra Aufruf der Funktion verbunden ist, zu vermeiden, benutz einfach das folgende:

template<typename T>
T destringify(std::string const& input)
{
	T output;
	std::istringstream stream(input);
	if(!(stream>>output))
	{
		// HANDLE ERROR HERE
	}
	return output;

}

Es wäre alles. Jetzt kannst du die Funktionalität von ‘toString’ und ‘stringTo…’ in C++ haben. Eine Sache noch — wenn du Templates benutzst sei vorsichtig wenn es um Deklaration / Definition geht. Ein Beispiel:

// Header file (foo.h)
template<typename T>
extern std::string stringify(T const& input);

// Source file (foo.cpp) -- definition provided above

// Main 
#include "foo.cpp"

Schwierig zu verstehen? Lies mal C++ FAQ.

Since there’s no standard ‘toString’ function in C++, one has to implement his own one to achieve a similar functionality. One of the possible solutions would be to use templates.

template<typename T>
std::string stringify(T const& input)
{
	std::ostringstream output;
	if(!(output<<input))
	{
		// HANDLE ERROR HERE
	}
	return output.str();
}

You can also implement your ‘stringTo…’ using a code like this.

template<typename T>
void destringify_intern(std::string const& input, T& output)
{
	std::istringstream stream(input);
	if(!(stream>>output))
	{
		// HANDLE ERROR HERE
	}
}

I did use the ‘intern’ suffix since one can write a wrapper function which does actually return something instead of operating only on references. Or to avoid an overhead associated with an extra function call, just use the following:

template<typename T>
T destringify(std::string const& input)
{
	T output;
	std::istringstream stream(input);
	if(!(stream>>output))
	{
		// HANDLE ERROR HERE
	}
	return output;

}

This is it, now you can utilize the functionality of ‘toString’ and ‘stringTo…’ in C++. One more thing — using templates beware of declaration / definition issues. Long story short:

// Header file (foo.h)
template<typename T>
extern std::string stringify(T const& input);

// Source file (foo.cpp) -- definition provided above

// Main 
#include "foo.cpp"

Problems understanding? Read the C++ FAQ.