template <class T>
T funktion()
{
	T ret;
	string strret;
	bool str = typeid(T) == typeid(string);

	//...

	return (str ? strret : ret);
}

funktion<int>();

Der Fehler ist, dass er "strret" nicht in int convertieren kann.

Warum der compiler fehler macht, ist mir klar, da er zur compile-zeit nicht wissen kann, welchen Wert str hat.

Wie kann ich das machen, ohne das der compiler rummurrt?

template <class T>
T funktion()
{
  return (typeid(T) == typeid(string));
}

funktion<int>();

und in der Überfunktion das machen was du willst?

Ansonsten müsstest du string zu T casten können müssen dürfen... :xmas2:

#include <iostream>
#include <string>

template<typename T> T select_return_value(T ret, std::string const &) { return ret; }
inline std::string const &select_return_value(std::string const &, std::string const &strret) { return strret; }

template<typename T>
T funktionsvorlage() {
  T ret = T();
  std::string strret = "foo";

  return select_return_value(ret, strret);
}

int main() {
  std::cout << funktionsvorlage<int>()         << '\n'
            << funktionsvorlage<std::string>() << '\n';
}

...aber du solltest SeppJs Vorschlag ernst nehmen.

Meine Funktion sieht im Moment ungefähr so aus: (Unwichtige Teile habe ich ausgelassen)

template <class T>
T funktion()
{
	T ret;
	string strret;
	bool str = typeid(T) == typeid(string);

	//...

	return (str ? strret : ret);
}

funktion<int>();

Der Fehler ist, dass er "strret" nicht in int convertieren kann.

Warum der compiler fehler macht, ist mir klar, da er zur compile-zeit nicht wissen kann, welchen Wert str hat.

Wie kann ich das machen, ohne das der compiler rummurrt?

Kann mir einer erklären, was das machen soll und wieso ihr Lösungen dazu habt?

Funktion die sowohl int als auch string zurückgeben kann

Klar gibt es Loesungen. Dein eigentliches Problem liegt aber wahrscheinlich im Design.

}
wird wahrscheinlich nicht funktionieren die auto funktion.

string func(void);
int func(void);

string func(void){
 return "String";
}

int func(void){
return 10;
}

funktion überladen wäre auch möglich

Der return-Typ gehört nicht zur Signatur, demnach kann man eine Funktion nicht über den return-Typ überladen. Dein Beispiel kompiliert folglich nicht.

Ich hab zwar einige Code-abschnitte speziell für strings, der Rest gilt allerdings für alle erdenklichen typen...

Mein Problem ist somit zwar gelöst, gibt es aber noch eine Möglichkeit, die "hübscher" ist?

(Ich werde das mit der Spezialisierung jetzt erst einmal implementieren, davon wusste ich nichts)

Was mir daran allerdings missfällt: Ich hab dann haufenweise Code doppelt.

Ich hab zwar einige Code-abschnitte speziell für strings, der Rest gilt allerdings für alle erdenklichen typen...

Dann musst du halt deinen Code aufteilen (in Klassen/andere Funktionen), so dass du in der Spezialisierung allgemeinen Code nutzen kannst. Wie du das am besten machst, kann man ohne genauerer Kenntnisse deines Codes nicht sagen.