template <int i, typename T>
T foo()
{}

template<>
int foo<1>()
{
    return 1;
}

template<>
std::string foo<2>()
{
    return std::string("test");
}

Der Aufruf sieht dann z. B. so aus:

int main()
{
    std::string str = foo<2, std::string>();
}

Meine Frage ist jetzt ob man das auch irgendwie so lösen kann, dass ich statt

std::string str = foo<2, std::string>();

nur

std::string str = foo<2>();

schreiben kann. Also den zweiten Template-Parameter (den Typ) weg lassen kann.

// Edit

So würde es funktionieren. Vielleicht wird dadurch klarer was ich eigentlich will

template <int i, typename T>
struct foo
{};

template<>
struct foo<1, std::string>
{
    std::string t;
};

template<>
struct foo<2, std::string>
{
    int t;
};

template<int i>
struct bar
{
    foo<i, std::string> f;
};

int main()
{
    std::cout << bar<1>().f.t << std::endl;
    std::cout << bar<2>().f.t;
}

Gibt es da ne elegantere Möglichkeit?

// Edit 2

Ich stand wohl irgendwie aufm Schlauch, weil ich so auf Funktionstemplates fixiert war und es anschließend mit Structs versucht hab.

So sieht nun die Lösung aus, ich frag mich wieso ich da net gleich drauf gekommen bin

template <int i>
struct foo
{};

template<>
struct foo<1>
{
    std::string t;
};

template<>
struct foo<2>
{
    int t;
};

Kann man Threads löschen lassen?

Kann man Threads löschen lassen?

Nur im Notfall. Man kann sie stehen lassen dass andere sich das durchlesen können und evtl. Lösungen für ihr eigenen Probleme finden

So sieht nun die Lösung aus, ich frag mich wieso ich da net gleich drauf gekommen bin

template <int i>
struct foo
{};

template<>
struct foo<1>
{
    std::string t;
};

template<>
struct foo<2>
{
    int t;
};

So kannst du aber nicht entweder std::string oder int zurückgeben, sondern nur die jeweilige Wrapper-Struktur. Meinst du nicht vielleicht sowas?

template <int i>
struct foo; // Keine Definition

template<>
struct foo<1>
{
    typedef std::string type;
};

template<>
struct foo<2>
{
    typedef int type;
};

template <int i>
typename foo<i>::type bar();

Wobei mir zwei benannte Funktionen sinnvoller scheinen, wenn die beiden bar() s was anderes tun. Denn nur weil man Templates nutzen kann, müssen sie nicht immer angebracht sein.

std::string bar1();
int bar2();

Max0r schrieb:

So sieht nun die Lösung aus, ich frag mich wieso ich da net gleich drauf gekommen bin

template <int i>
struct foo
{};

template<>
struct foo<1>
{
    std::string t;
};

template<>
struct foo<2>
{
    int t;
};

So kannst du aber nicht entweder std::string oder int zurückgeben, sondern nur die jeweilige Wrapper-Struktur. Meinst du nicht vielleicht sowas?

/*...*/

Nein, ich hab schon das gemeint was ich geschrieben hab.

Nexus schrieb:

Wobei mir zwei benannte Funktionen sinnvoller scheinen, wenn die beiden bar()s was anderes tun. Denn nur weil man Templates nutzen kann, müssen sie nicht immer angebracht sein.

Ich wollte es eben vermeiden, verschiedene Funktionen anzubieten und es besser über eine einzige machen (bzw. Struktur mit den Daten, die ich brauch).

Ich wollte es eben vermeiden, verschiedene Funktionen anzubieten und es besser über eine einzige machen (bzw. Struktur mit den Daten, die ich brauch).

Zwei verschiedene Funktionen hast du ohnehin. Ich meine nur, Templates haben primär den Zweck, viele Anwendungsfälle generisch zu behandeln. Wenn man nur zwei Fälle hat und diese jeweils spezialisiert behandeln muss, kann man geradeso gut auf Templates verzichten und ein Konzept wie Überladung einsetzen. Dann benötigt man auch viel weniger Code.