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>()
    

  • Mod

    Wo wäre da noch der Unterschied zu

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

    ?



  • 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?



  • 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
    

  • Mod

    edit:


  • Mod

    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.



  • 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;
    }
    

Log in to reply