Get-Typen von C++ - Funktionsparametern

Question

Gibt es eine Standardmethode, um die Typen der Argumente einer Funktion abzurufen und diese Typen als Vorlageparameterpaket weiterzugeben? Ich weiß, dass dies in C++ möglich ist, weil it has been done before.

Ich habe gehofft, dass hier mit 14 C++ oder dem bevorstehenden C++ 1z, gäbe es einen idiomatischen Weg arg_types<F>... zu implementieren:

template <typename ...Params> 
void some_function(); // Params = const char* and const char* 

FILE* fopen(const char* restrict filename, const char* restrict mode); 

int main(){ 
    some_function<arg_types<fopen>...>(); 
} 

Nur klar zu sein, eine Antwort behauptet, dass es Keine Standardmethode, dies zu tun, ist keine Antwort. Wenn es keine Antwort gibt, würde ich bevorzugen, dass die Frage unbeantwortet bleibt, bis die Lösung zu C++ 500 hinzugefügt wird oder bis zum Hitzetod des Universums, je nachdem, was früher passiert :)

Edit: Eine gelöschte Antwort darauf hingewiesen, dass ich kann PRETTY_FUNCTION verwenden, um die Namen von Parametertypen abzurufen. Ich möchte jedoch die tatsächlichen Typen. Nicht die Namen dieser Typen.

Answer 1

Diese Syntax ist etwas anders.

Erstens, weil Typen leichter zu verarbeiten sind als Packs, ein Typ, der eine Packung enthält. Die using type=types; spart mir nur im Code arbeiten, die eine types erzeugt: Hier

template<class...>struct types{using type=types;}; 

ist das Zugpferd. Es nimmt eine Signatur und erzeugt ein types<?...>-Bündel, das die Argumente für die Signatur enthält. 3 Schritte, damit wir schöne saubere C++ 14esque Syntax erhalten:

template<class Sig> struct args; 
template<class R, class...Args> 
struct args<R(Args...)>:types<Args...>{}; 
template<class Sig> using args_t=typename args<Sig>::type; 

Hier ist eine Syntax Unterschied. Anstatt direkt Params... einzunehmen, nehmen wir eine types<Params...>. Dies ist vergleichbar mit dem „Tag Dispatching“ -Muster, wo wir Template-Funktion Typ Abzug ausnutzen Argumente in der Typliste zu verschieben:

template <class...Params> 
void some_function(types<Params...>) { 
} 

Mein fopen ist anders, weil ich es will #include nicht die Mühe Sachen ing:

void* fopen(const char* filename, const char* mode); 

und die Syntax wird aus der fopen basiert, sondern vielmehr die Typ von fopen. Wenn Sie einen Zeiger haben, müssen Sie decltype(*func_ptr) oder soetwas tun. Oder wir könnten die oben erweitern R(*)(Args...) für einfache Bedienung zu handhaben:

int main(){ 
    some_function(args_t<decltype(fopen)>{}); 
} 

live example.

Beachten Sie, dass dies nicht arbeitet mit überladenen Funktionen, noch funktioniert es mit Funktionsobjekten.

Im Allgemeinen ist diese Art von Sache eine schlechte Idee, weil Sie normalerweise wissen, wie Sie mit einem Objekt interagieren.

Das obige wäre nur nützlich, wenn Sie eine Funktion (oder einen Funktionszeiger) nehmen und einige Argumente von irgendeinem Stapel irgendwo abheben und ihn auf der Basis der erwarteten Parameter oder etwas Ähnlichem aufrufen möchten.

Answer 2

Verwenden Sie Boost.FunctionTypes und std::index_sequence. Im Folgenden finden Sie ein Beispiel, in dem die Argumenttypen der Funktion func ausgegeben werden.Sie können die statische Funktion doit ändern, um das zu tun, was Sie wollen. Sehen Sie es in Aktion here.

template <typename FuncType> 
using Arity = boost::function_types::function_arity<FuncType>; 

template <typename FuncType> 
using ResultType = typename boost::function_types::result_type<FuncType>::type; 

template <typename FuncType, size_t ArgIndex> 
using ArgType = typename boost::mpl::at_c<boost::function_types::parameter_types<FuncType>, ArgIndex>::type; 

void func(int, char, double) {} 

template <typename Func, typename IndexSeq> 
struct ArgPrintHelper; 

template <typename Func, size_t... Inds> 
struct ArgPrintHelper<Func, integer_sequence<size_t, Inds...> > 
{ 
    static void doit() 
    { 
    string typeNames[] = {typeid(ResultType<Arg>).name(), typeid(ArgType<Func, Inds>).name()...}; 
    for (auto const& name : typeNames) 
     cout << name << " "; 
    cout << endl; 
    } 
}; 

template <typename Func> 
void ArgPrinter(Func f) 
{ 
    ArgPrintHelper<Func, make_index_sequence<Arity<Func>::value> >::doit(); 
} 

int main() 
{ 
    ArgPrinter(func); 
    return 0; 
} 

Headers (bewegte hier unten Rauschen in dem obigen Codeausschnitt zu verkleinern):

#include <boost/function_types/function_type.hpp> 
#include <boost/function_types/parameter_types.hpp> 
#include <boost/function_types/result_type.hpp> 
#include <boost/function_types/function_arity.hpp> 

#include <algorithm> 
#include <iostream> 
#include <string> 
#include <type_traits> 
#include <typeinfo> 
#include <tuple> 
#include <utility> 
using namespace std;