C++ template mechanism to get the number of function arguments, which would work for lambdas and normal functions

Question

I am trying to implement a mechanism, which would provide me some information about the template argument function type. Main idea is to get the number of arguments, return type, total sum of sizes of each argument. I have something running for lambdas based on this entry.

template <typename T, typename... Args>
struct sumSizeOfArgs {
    enum { totalSize = sizeof(typename std::decay<T>::type) + sumSizeOfArgs<Args...>::totalSize };
};

template<typename T>
struct sumSizeOfArgs<T> {
    enum  {totalSize = sizeof(typename std::decay<T>::type)};
};
}             
template <typename T>
struct function_traits : public function_traits<decltype(&T::operator())>
{};

template <typename ClassType, typename ReturnType, typename... Args>

struct function_traits<ReturnType(ClassType::*)(Args...) const>
{
  enum { arity = sizeof...(Args) };

  typedef ReturnType result_type;

enum { totalSize = sumSizeOfArgs<Args...>::totalSize };

template <size_t i>
struct arg
{
    typedef typename std::tuple_element<i, std::tuple<Args...>>::type type;
};
};

However, indeed this code does not work for normal functions types such as

 function_traits<void()>

it does not have an operator(). I would greatly appreciate, any suggestion to make this code work for both cases. Thanks,

Your `sumSizeOfArgs` is of limited utility, as it will choke when instantiated with 0 template-arguments. You might want to correct that. — Deduplicator, Nov 19 '14 at 18:45

score 4 · Accepted Answer · edited May 23 '17 at 11:59

Slightly improved original part:

#include <tuple>
#include <type_traits>

template <typename... Args>
struct sumSizeOfArgs
{
    static constexpr size_t totalSize = 0;
};

template <typename T, typename... Args>
struct sumSizeOfArgs<T, Args...>
{
    static constexpr size_t totalSize = sizeof(typename std::decay<T>::type)
                                        + sumSizeOfArgs<Args...>::totalSize;
};

template <typename T>
struct sumSizeOfArgs<T>
{
    static constexpr size_t totalSize = sizeof(typename std::decay<T>::type);
};

template <typename T>
struct function_traits_impl;

template <typename ClassType, typename ReturnType, typename... Args>
struct function_traits_impl<ReturnType(ClassType::*)(Args...)>
{
    static constexpr size_t arity = sizeof...(Args);

    using result_type = ReturnType;

    static constexpr size_t totalSize = sumSizeOfArgs<Args...>::totalSize;

    template <size_t i>
    struct arg
    {
        using type = typename std::tuple_element<i, std::tuple<Args...>>::type;
    };
};

template <typename ClassType, typename ReturnType, typename... Args>
struct function_traits_impl<ReturnType(ClassType::*)(Args...) const>
    : function_traits_impl<ReturnType(ClassType::*)(Args...)> {};

New part starts here (traits' class partial specialization for functions):

template <typename ReturnType, typename... Args>
struct function_traits_impl<ReturnType(Args...)>
{
    static constexpr size_t arity = sizeof...(Args);

    using result_type = ReturnType;

    static constexpr size_t totalSize = sumSizeOfArgs<Args...>::totalSize;

    template <size_t i>
    struct arg
    {
        using type = typename std::tuple_element<i, std::tuple<Args...>>::type;
    };
};

template <typename ReturnType, typename... Args>
struct function_traits_impl<ReturnType(*)(Args...)>
    : function_traits_impl<ReturnType(Args...)> {};

Crucial part is here (determining the presence of operator()):

template <typename T, typename V = void>
struct function_traits
    : function_traits_impl<T> {};

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

Test:

int main()
{
    static_assert(function_traits<void()>::arity == 0, "!");

    static_assert(function_traits<void(int)>::arity == 1, "!");

    static_assert(function_traits<void(*)(int, float)>::arity == 2, "!");  

    auto lambda = [] (int, float, char) {};
    static_assert(function_traits<decltype(lambda)>::arity == 3, "!");

    auto mutable_lambda = [] (int, float, char, double) mutable {};
    static_assert(function_traits<decltype(mutable_lambda)>::arity == 4, "!");
}

DEMO 1

Or even simpler, with a single trait class:

#include <tuple>

template <typename ReturnType, typename... Args>
struct function_traits_defs
{
    static constexpr size_t arity = sizeof...(Args);

    using result_type = ReturnType;

    template <size_t i>
    struct arg
    {
        using type = typename std::tuple_element<i, std::tuple<Args...>>::type;
    };
};

template <typename T>
struct function_traits_impl;

template <typename ReturnType, typename... Args>
struct function_traits_impl<ReturnType(Args...)>
    : function_traits_defs<ReturnType, Args...> {};

template <typename ReturnType, typename... Args>
struct function_traits_impl<ReturnType(*)(Args...)>
    : function_traits_defs<ReturnType, Args...> {};

template <typename ClassType, typename ReturnType, typename... Args>
struct function_traits_impl<ReturnType(ClassType::*)(Args...)>
    : function_traits_defs<ReturnType, Args...> {};

template <typename ClassType, typename ReturnType, typename... Args>
struct function_traits_impl<ReturnType(ClassType::*)(Args...) const>
    : function_traits_defs<ReturnType, Args...> {};

// + other cv-ref-variations

template <typename T, typename V = void>
struct function_traits
    : function_traits_impl<T> {};

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

int main()
{
    static_assert(function_traits<void()>::arity == 0, "!");

    static_assert(function_traits<void(int)>::arity == 1, "!");

    static_assert(function_traits<void(*)(int, float)>::arity == 2, "!");  

    auto lambda = [] (int, float, char) {};
    static_assert(function_traits<decltype(lambda)>::arity == 3, "!");

    auto mutable_lambda = [] (int, float, char, double) mutable {};
    static_assert(function_traits<decltype(mutable_lambda)>::arity == 4, "!");

    struct Functor
    {
        void operator()(int) {}
    };
    static_assert(function_traits<Functor>::arity == 1, "!");
}

DEMO 2

Note: Unfortunately none of the above solutions will work for generic lambdas, related discussion is Arity of a generic lambda

Worth noting that taking the address of `operator()` obviously won't work for polymorphic lambdas. — T.C., Nov 19 '14 at 20:54
This looks great thank you! Can you explain to me this part actually, what is this specialization why (void)? template struct function_traits : function_traits_impl {}; — edorado, Nov 19 '14 at 21:45
@edorado: (1). The *name lookup* finds *primary template*; (2). Compiler searches for specialization (using `void` as second argument); (3). Compiler tries to instantiate the specialization with `decltype((void)&T::operator())`; (4). If the expression in `decltype` is *well-formed*, it gets casted to `void` and hence is treated by compiler as viable *partial-specialization* that can be used (which is designed to work with `operator()`), otherwise, it falls back to *primary template*, and uses that class template for functions. [See video](https://www.youtube.com/watch?v=a0FliKwcwXE&t=29m06s) — Piotr Skotnicki, Nov 19 '14 at 21:54
Really minor thing, you could add a specialization for `ReturnType(&)(Args...)`, or put a template in front that decays T. That way it works for things like types deduced from rvalue refs such as here `template void foo(T&& f) { function_traits::arity; }` — Sander Mertens, May 13 '21 at 03:18

C++ template mechanism to get the number of function arguments, which would work for lambdas and normal functions

1 Answers1