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.

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

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?

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.

Für den Anwendungsfall sind die aber nicht brauchbar.

Warum nicht?

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