char - ist klar

char c='C';
std::string s(c);

short - wie?

int - klar

int i=1;
std::string s=atoi(i);

long - klar

long l=4 /*Was ist denn eine gute Benutzung für long? Hex-Zahlen?*/
std::string s=atol(l);

float - wie? (auch atof()?)

double - klar

float f=0.123456
std::string s=atof(f);

long double - bracuht man das überhaupt?!

danke

std::stringstream Buffer;
Buffer << //Alles was du auch über std::cout ausgeben kannst
std::string Result(Buffer.str());

Siehe dir doch noch mal
http://www.cplusplus.com/reference/clibrary/cstdlib/atoi/
an

int

std::string s = "1";
int i = atoi(s)

long

std::string s = "0x7FFFFF"; /*Hex Zahlen bei long?!*/
int l = atol(s)

double

std::string s = "0.12345678901234";
double d = atof(s);

Hatte ursprünglich auch die stringstream variante und dann eben eine funktion, die mir den veränderten string zurückgibt, allerdings wollte ich das nach möglichkeit in einem einzeiler machen, deswegen habe ich auf atof, atoi etc. zurück gegriffen..
Aber wenn das unsinnig wird, werde ich wieder an die stringstream variante gehen; eine frage allerdings noch (s.o.) ich habe den datentyp long so noch nie genutzt, benutzt man long um hex zahlen auszugeben`?!

std::string s = "0x7FFFFF"; /*Hex Zahlen bei long?!*/
long l = atol(s)

....

... benutzt man long um hex zahlen auszugeben`?!

Datentyp und Schreibweise sind zwei Paar Schuhe.

...eine frage allerdings noch (s.o.) ich habe den datentyp long so noch nie genutzt, benutzt man long um hex zahlen auszugeben`?!

Der Datentyp hat nicht wirklich etwas mit dem Zahlensystem zu tun, mit dem du den Zahlenwert darstellt.

Ob du nun

16       - dezimal
10000    - binaer
020      - octal
0x10     - hexadezimal

schreibst, ist ziemlich egal, es handelt sich immer um den gleichen Zahlenwert.

Also sind

long l1 = 16l;
long l2 = 0x10l;

äquivalent.

long und int können, abhängig vom verwendeten System, unterschiedliche Wertebereiche haben. Auf einem 16bit System ist int üblicherweise 2byte gross und long 4byte, auf einem 32bit System sind beide 4byte gross (gleicher Wertebereich). Auf 64bit Systemen könnte long wieder einen grösseren Wertebereich haben als int.

#include <iostream>
#include <sstream>
#include <typeinfo>

template<typename target_t, typename source_t>
target_t convert(source_t const &src) {
  target_t result;
  std::stringstream converter;

  converter << src;
  converter >> result;

  if(!converter) throw std::bad_cast();

  return result;
}

int main() {
  std::cout << convert<int>("123") * 2 << std::endl; // 246
  std::cout << convert<int>("abc");                  // wirft std::bad_cast
}

Vorsicht ist dabei im Umgang mit Zeigern und Referenzen geboten - convert<char*>(123) beispielsweise erzeugt undefiniertes Verhalten, ebenso die Rückgabe von Referenzen. Womöglich wäre es sinnvoll, diese gleich zur Compilezeit auszusortieren:

#include <iostream>
#include <sstream>
#include <typeinfo>

template<typename T> struct assert_direct_type { typedef T type; };
template<typename T> struct assert_direct_type<T*> { };
template<typename T> struct assert_direct_type<T&> { };

template<typename target_t, typename source_t>
target_t convert(source_t const &src) {
  typename assert_direct_type<target_t>::type result;
  std::stringstream converter;

  converter << src;
  converter >> result;

  if(!converter) throw std::bad_cast();

  return result;
}

(Wird auch allerhöchste Zeit...)

Ab C++0x hat man zudem std::to_string() zur Verfügung.

(Wird auch allerhöchste Zeit...)

Wow, das ist ja cool
Wieder ein tolles neues Feature von C++0x kennengelernt, dankeschön!