Tworzenie szablonu na lambdzie w C++0x

Sztuczka void_t może pomóc. Jak działa 'void_t' ?

Jeśli nie masz C++17, musisz podać definicję void_t:

template<typename... Ts> struct make_void { typedef void type;};
template<typename... Ts> using void_t = typename make_void<Ts...>::type;

Dodaj dodatkowy argument szablonu do oryginalnego szablonu, domyślnie void:

template <typename T, typename = void>
struct function_traits;

Obiekt cech dla prostych funkcji jest taki sam jak już masz:

template <typename R, typename... A>
struct function_traits<R (*)(A...)>
{
    using return_type = R;
    using class_type  = void;
    using args_type   = std:: tuple< A... >;
};

Dla metod non-const:

template <typename R, typename... A>
struct function_traits<R (*)(A...)>
{
    using return_type = R;
    using class_type  = void;
    using args_type   = std:: tuple< A... >;
};

Nie zapomnij const metody:

template <typename R, typename C, typename... A>
struct function_traits<R (C::*)(A...) const> // const
{
    using return_type = R;
    using class_type  = C;
    using args_type   = std:: tuple< A... >;
};

Wreszcie ważna cecha. Dana klasa typ, w tym typy lambda, chcemy przejść z T do decltype(&T::operator()). Chcemy mieć pewność, że ta cecha jest dostępna tylko dla typów T, dla których ::operator() jest dostępna, a to robi dla nas void_t. Aby wyegzekwować to ograniczenie, musimy umieścić &T::operator() gdzieś w podpisie cechy, stąd template <typename T> struct function_traits<T, void_t< decltype(&T::operator())

template <typename T>
struct   function_traits<T, void_t< decltype(&T::operator()) > > 
: public function_traits<           decltype(&T::operator())   >
{
};

Metoda operator() w lambdzie (non-mutable, non-generic) to const, co wyjaśnia, dlaczego potrzebujemy szablonu const powyżej.

Ale ostatecznie jest to bardzo restrykcyjne. Nie będzie to działać z ogólnymi lambdami lub obiektami z szablonami operator(). Jeśli ponownie rozważysz swój projekt, znajdziesz inne podejście, które jest bardziej elastyczne.

Delegując część pracy do serii szablonów funkcji zamiast szablonu klasy , możesz wyodrębnić odpowiednie informacje.

Najpierw jednak powinienem powiedzieć, że odpowiednia metoda jest metodą const, dla Lambda (Dla Nie-przechwytywania, nie-generycznego, nie-mutable lambda). Więc nie będziesz w stanie odróżnić prawdziwej lambdy od tej: {]}

struct {
    int operator() (int) const { return 7; }
} object_of_unnamed_name_and_with_suitable_method;

Dlatego muszę założyć, że nie chcesz "specjalnego traktowania" lambdy i nie chcesz sprawdzić, czy typ jest typem lambda, a zamiast tego chcesz po prostu wyodrębnić typ zwracany i typ wszystkich argumentów dla dowolnego obiektu, który jest wystarczająco prosty. Przez "dość proste" Rozumiem na przykład, że metoda operator() jest , a nie sama w sobie szablonem. I, dla informacji bonusowych, logiczny, aby powiedzieć nam, czy operator() metoda była obecna i używana, w przeciwieństwie do zwykłej starej funkcji.

// First, a convenient struct in which to store all the results:
template<bool is_method_, bool is_const_method_, typename C, typename R, typename ...Args>
struct function_traits_results {
    constexpr static bool is_method = is_method_;
    constexpr static bool is_const_method = is_const_method_;
    typedef C class_type; // void for plain functions. Otherwise,
                          // the functor/lambda type
    typedef R return_type;
    typedef tuple<Args...> args_type_as_tuple;
};

// This will extract all the details from a method-signature:
template<typename>
struct intermediate_step;
template<typename R, typename C, typename ...Args>
struct intermediate_step<R (C::*) (Args...)>  // non-const methods
    : public function_traits_results<true, false, C, R, Args...>
{
};
template<typename R, typename C, typename ...Args>
struct intermediate_step<R (C::*) (Args...) const> // const methods
    : public function_traits_results<true, true, C, R, Args...>
{
};


// These next two overloads do the initial task of separating
// plain function pointers for functors with ::operator()
template<typename R, typename ...Args>
function_traits_results<false, false, void, R, Args...>
function_traits_helper(R (*) (Args...) );
template<typename F, typename ..., typename MemberType = decltype(&F::operator()) >
intermediate_step<MemberType>
function_traits_helper(F);


// Finally, the actual `function_traits` struct, that delegates
// everything to the helper
template <typename T>
struct function_traits : public decltype(function_traits_helper( declval<T>() ) )
{
};