3. Von Funktionstyp die Parameter extrahieren

Von Funktionstyp die Parameter extrahieren

  • B

    Hi,

    wenn ich irgendwo einen Typ der Form void(int,char) (oder so ähnlich) vermerkt habe, kann ich da irgendwie die Parameter extrahieren?
    Das einzige, was ich mit Probieren herausfinden konnte, war dieses:

    template<class R, class P1, class P2>
void unfold( R(*)(P1,P2) )
{
	cout << typeid(R).name() << " foo( " << typeid(P1).name() << ", " << typeid(P2).name() << " )" << endl;
}

template<class T>
void foo()
{
	cout << typeid(T).name() << endl;
	unfold( reinterpret_cast<T*>((void*)0) );
}

foo<int(char,double)>();

    Allerdings ist das Extrahieren per Funktion ja Mist, weil ich dann nicht z.B.

    template<class Signature>
class Foo
{
    typedef Irgendwas RetType;
};

    anwenden kann.

    In boost::function hab ich auch herumgeschnüffelt, da verstehe ich aber null.

    Grüße,
    Badestrand

    0
  • Administrator

    Keine Ahnung, wie die Boost-Leute das hinbekommen, aber damit geht es:
    http://www.boost.org/doc/libs/1_37_0/libs/type_traits/doc/html/boost_typetraits/reference/function_traits.html

    Edit: Inzwischen verstanden. Pöh, so einfach, hätte ich auch selber drauf kommen sollen ^^"

    Grüssli

    0
  • B

    Danke, ist ja echt voll einfach 😃

    0
  • Administrator

    Hab mich gerade selber noch etwas mit dem Zeug beschäftigt, rein aus Interesse und mir sind da ein paar Fragen aufgetaucht, welche thematisch gleich in den Thread passen. Selber habe ich es kurz so gelöst:

    #include <boost/mpl/at.hpp>
#include <boost/mpl/vector.hpp>

#include <iostream>

template<typename FuncT>
struct FunctionArgs;

template<typename R>
struct FunctionArgs<R(void)>
{
	typedef R Result;
};

template<typename R, typename T>
struct FunctionArgs<R(T)>
{
	typedef R Result;
	typedef boost::mpl::vector<T> Args;
};

template<typename R, typename T1, typename T2>
struct FunctionArgs<R(T1, T2)>
{
	typedef R Result;
	typedef boost::mpl::vector<T1, T2> Args;
};

// ...

int main()
{
	std::cout << typeid(FunctionArgs<int()>::Result).name() << std::endl;
	std::cout << typeid(boost::mpl::at_c<FunctionArgs<void(int,char)>::Args, 1>::type).name() << std::endl;

	return 0;
}

    Hauptunterschied zur Boost-Version sind die folgenden und ich frage mich, wieso die Boostleute es anders gemacht haben. Vielleicht kann mir jemand einen Tipp geben, was der Grund sein könnte:
    - Bei Boost wird dem Funkionstyp ein Zeiger dazugefügt. So sind alle Spezialisierungen von folgender Form: R (*)(T1, T2, T3, TX...)
    Wie man unschwer sieht, habe ich das ohne gemacht und bei mir funktioniert das wunderbar. Mir fällt auch kein Grund ein, wieso man da einen Zeiger dazufügen sollte. Hat einer eine Idee?
    - Ich habe die Boost.MPL genutzt um die Argumente aufzulisten. Finde ich irgendwie sinnvoller, da man dann gleich die MPL Algorithmen verwenden kann. Wieso wurde nicht der Boost.MPL vector für die Auflistung der Argumente verwendet?

    Ich will es zuerst hier versuchen zu fragen, bevor ich mein Englisch hervorkramen muss, um in der Boost.MailingList zu fragen 😃

    Zudem noch eine Frage zum neuen Standard, an die, welche sich da schon etwas besser auskennen. Wäre sowas irgendwie mit Variadic Templates machbar und wenn ja, wie? Kann mir schlecht vorstellen, dass sowas gehen wird:

    template<typename R, typename... T>
struct FunctionArgs<R(T...)>
{
	typedef R Result;
	typedef boost::mpl::vector<T...> Args;
};

    Natürlich unter der Voraussetzung, dass boost::mpl::vector auch die Variadic Templates unterstützt. Aber das Hauptproblem sehe ich in der Spezialisierung, wäre ja zu schön, wenn das der Kompiler aktzeptieren würde 🙂

    Grüssli

    0
Anmelden zum Antworten