return type überladen

Ist es in C++ möglich den return Typ einer Funktion mit Templates zu ändern?
Aber nicht so

template<class T>
T foo()

sondern so in etwa: (kompiliert natürlich nicht )

template<int N>
void foo() 

template<>
int foo<0>()

template<>
char foo<1>()

SeppJ

Wo wäre da noch der Unterschied zu

void foo();
int foo_0();
char foo_1();

?

volkard

SeppJ schrieb:

Wo wäre da noch der Unterschied zu
void foo();
int foo_0();
char foo_1();
?

In der Verwendung

auto x=foo<declytype(y)>();

Ich dachte der Rückgabetyp einer Funktion lässt sich in C++ nicht überladen. Sprich, int foo() und void foo() können nicht gleichzeitig definiert werden. Das dürfte dann doch für Templates auch gelten oder etwa nicht?

CStoll

Bei deinem TEmplate überlädst du auch nicht, sondern spezialisierst es - und solange du die verwendete Spezialisierung explizit angibst, gibt es damit keine Probleme. Man denke nur an Konstruktionen wie:

template<typename TGT,typename SRC>
TGT my_cast(SRC) {...}
//SRC kann der Compiler selber ermitteln, TGT (und damit den Rückgabetyp) mußt du explizit angeben

SeppJ

edit:

camper

z.B.

namespace mpl = boost::mpl;
typedef mpl::vector<char, int, void> types;
template <int N>
typename mpl::eval_if<(N<mpl::size<types>::type::value),mpl::at<types,mpl::int_<N>>,mpl::back<types>>::type foo();

geht auch mit tuple statt vector. Oder man nimmt eine map.

Nexus

Oder wieder ein Alexandrescu-Trick:

template <int N>
struct Int2Type {};

Anwendung:

template<int N>
void foo(Int2Type<N>);

int foo(Int2Type<0>);

char foo(Int2Type<1>);

Oder geht es dir darum, nur eine Funktion zu haben, deren Rückgabetyp von einem Templateparameter abhängt? Dann könntest du mit Traits arbeiten.

#include <iostream>

template<int N> struct type_mapper;
template<> struct type_mapper<0> { typedef int type; };
template<> struct type_mapper<1> { typedef char type; };

template<int N> typename type_mapper<N>::type foo();

template<> int  foo<0>() { return   1; }
template<> char foo<1>() { return 'A'; }

int main() {
  std::cout << foo<0>() << foo<1>() << std::endl;
}