✔ [C++]Stringstream

[kickerxy123]

Hallo,

mir ist heute ein interessantes problem aufgetaucht:

string hallo = "wie geht es dir";
stringstream strstr;
strstr << hallo;
string out = "";
strstr >> out;

cout << out; //liefert "wie" und nicht "wie geht es dir"

Ich kann mir schon denken, warum stringstream so etwas macht. Es wäre ja normalerweise auch kein Problem (bei z.B. floatToString o.ä. dürfen ja auch keine lücken auftauchen). Hintergrund ist folgender..
ich verwende:

 template <typename AnyType>
void myFunc(AnyType* msg)
{
//do sth.
}

Nun darf (und es kommt auch vor) "msg" als String übergeben werden. Meine Funktion muss also sowohl mit Ints, Doubles, floats, ... als auch Strings, char*, ... klar kommen. In dem Fall, dass eine Zeichenkette übergeben wird, soll stringstream eigentlich gar nichts unternehmen...
also meine Frage: kann ich den übergebenen Typen bestimmen und so bei strings anders verfahren?

Danke und Gruß

 

[deepthroat]

Hi.

Dann gib doch einfach eine Spezialisierung der Template-Funktion für std::string an.

Gruß

 

[kickerxy123]

Hi, danke für die Antwort.
Ja ok. Wenn ich dich richtig verstanden habe:

 template <typename AnyType>
void myFunc(AnyType* msg)
{
//do sth.
};
void myFunc(string* msg)
{
//do sth.
};
void myFunc(const char* msg)
{
//do sth.
};

Das funktioniert auch. Ist das denn "saubere" Programmierung?

ps: vor allem... dann habe ich wieder 4mal (fast) den selben Code... dafür hab ich ja eigentlich nen template verwendet um das zu vermeiden.. Denn so hab ich AnyType, std::string, const char* und char*. Kann denn nicht zu Laufzeit der übergebene Typ in der Templatefunktion ermittelt werden?

Danke und Gruß

 

[deepthroat]

Hi.

Hi, danke für die Antwort.
Ja ok. Wenn ich dich richtig verstanden habe:

Nein, nicht ganz:

template <>
void myFunc<std::string*>(std::string* str) {
  ...
}

ps: vor allem... dann habe ich wieder 4mal (fast) den selben Code... dafür hab ich ja eigentlich nen template verwendet um das zu vermeiden.. Denn so hab ich AnyType, std::string, const char* und char*.

Wenn du für verschiedene Typen innerhalb eines Templates unterschiedlichen Code verwenden willst, mußt du spezialisieren.

Kann denn nicht zu Laufzeit der übergebene Typ in der Templatefunktion ermittelt werden?

Du könntest den variablen Teil als Trait aus der Funktion herauslösen:

template <typename T> struct read_trait {
  static ::std::stream read(::std::stream& s, T& x) {
    // Standard Implementierung
    ...
  }
};

// Spezialisierung für std::string
template <> struct read_trait<std::string> {
  static ::std::stream read(::std::stream& s, std::string& s) {
    ...
  }
};

template <typename T>
void myFunc(T x) {
  typedef read_trait<T> trait;
  T v;
  if (trait::read(stream, v)) {
  }
}

Das kommt immer ganz auf die Anwendung an, was man genau machen will.

Gruß

 

[kickerxy123]

das mit der Spezialisierung klappt super und ist in meinem Fall gut einsetzbar.
Vielen Dank