auto aus C++0x simulieren


  • Administrator

    Hallo zusammen,

    Wollte mal nachfragen, wie man eigentlich das Schlüsselwort auto aus dem neuen Standard C++0x simulieren könnte oder zumindest teilweise?
    Also grundsätzlich wie man sowas vereinfacht:

    template<typename T1, typename T2, typename T3, typename T4>
    ReturnType<T1, T2, T3, T4> create(T1 const& a, T2 const& b, T3 const& c, T4 const& d)
    {
      // ...
      return ReturnType<T1, T2, T3, T4>(a, b, c, d);
    }
    
    // ...
    std::string str;
    std::vector<int> vec(5);
    ReturnType<std::vector<int>::iterator, std::vector<int>::pointer, bool, std::string> returnValue = create(vec.begin(), &vec[2], false, str);
    
    // Wie bekommt man diese Typedeklaration vor dem returnValue weg? Wie bei auto halt:
    auto returnValue = create(vec.begin(), &vec[2], false, str);
    

    Es ist einfach fast unzumutbar, wenn man sowas vom Programmierer verlangt. Und bis der neue Standard da ist, geht es wahrscheinlich noch ein Weilchen 😉

    Was für möglichkeiten gibt es?

    Grüssli



  • Geht im Allgemeinen nicht. Es gibt ein paar sehr schlimme Hacks welche zum Beispiel in boost.typeof oder boost.foreach Verwendung finden. Für den Anwendungsfall sind die aber nicht brauchbar. GCC hat ein buildin typeof.


  • Administrator

    Ben04 schrieb:

    Geht im Allgemeinen nicht.

    Und in was für Spezialfällen geht es? Ich möchte ja nicht unbedingt gleich die auto Funktionalität haben, einfach nur etwas, um es zu vereinfachen. Auch wenn die Vereinfachung nur in Spezialfällen funktioniert.

    Grüssli



  • Guck dir mal Boost.Typeof an, insbesondere das BOOST_AUTO Makro. Das benutzt den typeof-Operator des Compilers sofern vorhanden, ansonsten wird dessen Funktionalität emuliert, was allerdings überhaupt nicht mehr schön ist...

    Die Funktionsweise der Emulation ist hier noch ein bißchen genauer erklärt als in der Dokumentation.



  • Wäre für Schreibfaule nicht einfach ein typedef einfacher und übersichtlicher?



  • Fellhuhn schrieb:

    Wäre für Schreibfaule nicht einfach ein typedef einfacher und übersichtlicher?

    In vielen Fällen ist das leider nicht praktikabel. Nehmen wir mal das Beispiel aus der Boost.Typeof Doku.
    Der wirklich triviale Boost.Lambda-Ausdruck

    _1 > 15 && _2 < 20
    

    hat den Typ

    lambda_functor<
        lambda_functor_base<
            logical_action<and_action>,
            tuple<
                lambda_functor<
                    lambda_functor_base<
                        relational_action<greater_action>,
                        tuple<
                            lambda_functor<placeholder<1> >,
                            int const
                        > 
                    > 
                >,
                lambda_functor<
                    lambda_functor_base<
                        relational_action<less_action>,
                        tuple<
                            lambda_functor<placeholder<2> >,
                            int const 
                        > 
                    > 
                >
            > 
        > 
    >
    

    Sowas möchte man nicht wirklich tippen müssen, mal ganz abgesehen davon, daß man den genauen Typ bei sowas gar nicht genau wissen will (oder gar kann).

    Ähnliche Probleme kriegt man z.B. mit Regeln in Boost.Spirit, und ich bin sicher es gibt noch viele andere Fälle, wo auto sehr hilfreich wäre.



  • Ben04 schrieb:

    Für den Anwendungsfall sind die aber nicht brauchbar.

    Warum nicht?





  • Hallo

    Wenn du mit sowas spielen (Ich sage spielen, weil wirklich darauf verlassen in einem nicht-experimentalen Projekt würde ich mich noch nicht) willst, dann empfehle ich dir unbedingt mal einen Blick auf die Visual Studio 2010 CTP zu werfen. Dort funktionieren auto , lambda-expressions und einige andere Dinge aus C++0x schon ganz gut. Stell allerdings sicher, dass du einen starken PC zum Programmieren hast, denn du musst das ganze mit VirtualPC starten (der bootet dann Windooze Server 2008 und das ist tödlich mit unter 4GB Ram und Dual-Core Prozessoren :(). Kompilierte Programme laufen selbstverständlich auch ausserhalb von VirtualPC^^ Ist aber wie gesagt nur etwas für experimentierfreudige Leute mit viel Zeit 😉

    tipp schrieb:

    Hier gibts ne gut auto simulation
    http://www.c-plusplus.net/forum/viewtopic-var-p-is-1615085.html#1615085

    😃 👍

    MfG


Log in to reply