Rückgabewert einer Funktion (decltye?)



  • Ich würde gerne rein aus Übungszwecken eine Klasse schreiben, die eine FUnktion oder einen Funktor übergeben bekommt, und dann den Rückgabewert dieses Objekts zurückgibt.

    Momentan noch ohne Argument-Forwarding. Leider scheitere ich :

    #include <iostream>
    #include <algorithm>
    #include <iterator>
    #include <valarray>
    
    // soll aufgerufen werden
    class EulerDist2D
    {
    public:
        double operator()(const std::valarray<double>& v) const
        {
            double sum = 0.0;
    
            for(auto &i : v)
            {
                sum += i*i;
            }
    
            return sum;
        }
    };
    
    template <typename F>
    class Executor
    {
    public:
        F& foo;
        Executor(F& f): foo(f){}
    
        declytype(foo()) operator()()
        {
            std::valarray<double> p1 {3.6, 7.4};
            return foo(p1);
        }
    
    };
    
    int main()
    {
        EulerDist2D euler;
    
        Executor<EulerDist2D> exe(euler);
        exe();
    
        return 0;
    }
    

    Das sind meine ersten Gehversuche auf dem Gebiet, also nicht zu hart sein 🙂

    Wenn ich das soweit habe, möchte ich im Anschluss auch noch die Funktionsargumente forwarden.
    Das Anlegen des std::vectors p1 soll also in der Main dann geschehen.



  • Dein foo nimmt einen Parameter, deswegen geht decltype(foo()) nicht.
    -> decltype(foo(std::valarray<double>)) operator()()
    Oder viel einfacher:
    auto operator()()



  • Habe nun den Executor angepasst:

    template <typename F>
    class Executor
    {
    public:
        F& foo;
        Executor(F& f): foo(f){}
    
        decltype(foo(std::valarray<double>)) operator()()
        {
            std::valarray<double> p1 {3.6, 7.4};
            return foo(p1);
        }
    
    };
    

    Der Rückgabewert schint aber nun ein Int statt einem Double zu sein.
    Ein cout liefert: 67 statt 67.72.

    Habe zu Testzwecken mal eine andere Klasse geschrieben:

    class EulerDist3D
    {
    public:
        std::string operator()(const std::valarray<double>& v) const
        {
    
            return "Hello";
        }
    };
    

    Wenn ich diese in den Executor stecke, meckert der Compiler:

    error: cannot convert ‘std::string {aka std::basic_string<char>}’ to ‘int’ in return

    Demnach scheint er wirklich int als Rückgabewert zu haben. Was liegt nun noch im Argen?



  • Sorry, nimm
    decltype(foo(std::valarray<double>{}))

    Aber nimm wirklich lieber auto . Dann musst du dir keine Gedanken darum machen.



  • Danke, soweit geht es jetzt erstmal.

    Wenn ich allerdings auto verwende, bekomme ich folgenden Fehler:

    operator()’ function uses ‘auto’ type specifier without trailing return type [enabled by default]
    auto operator()()

    Es könnte sich dabei nur ein Compiler-Flag handeln, aber ich bin nicht sicher.

    Ein erstes googlen hat ergeben, dass -std=c++1y das Problem beheben soll.
    Muss ich aber noch testen



  • Mit C++11 lautet die Definition dafür wie folgt:

    auto operator()(...) -> <deintyp> { .. }



  • Habe nun mit c++14 kompiliert:

    internal compiler error: in gen_type_die_with_usage, at dwarf2out.c:19491

    Sieht nicht gut aus...


Anmelden zum Antworten