Мета-функция C++, определяющая, вызывается ли тип для заданных аргументов
Я пытаюсь реализовать мета-функцию шаблона C++, которая определяет, может ли тип вызываться из входных аргументов метода.
т. е. для функции void foo(double, double) мета-функция возвратит true на callable_t<foo, double, double>, true на callable_t<foo, int, int> (из-за компилятора делает неявное приведение) и false для чего-либо еще, такого как неправильное количество аргументов callable_t<foo, double>.
моя попытка выглядит следующим образом, однако она терпит неудачу для любой функции, которая возвращает что-либо, кроме void, и я не могу кажется, это исправить.
Я новичок в перепрограммировании шаблонов, поэтому любая помощь будет оценена.
#include <iostream>
#include <type_traits>
#include <utility>
#include <functional>
namespace impl
{
template <typename...>
struct callable_args
{
};
template <class F, class Args, class = void>
struct callable : std::false_type
{
};
template <class F, class... Args>
struct callable<F, callable_args<Args...>, std::result_of_t<F(Args...)>> : std::true_type
{
};
}
template <class F, class... Args>
struct callable : impl::callable<F, impl::callable_args<Args...>>
{
};
template <class F, class... Args>
constexpr auto callable_v = callable<F, Args...>::value;
int main()
{
{
using Func = std::function<void()>;
auto result = callable_v<Func>;
std::cout << "test 1 (should be 1) = " << result << std::endl;
}
{
using Func = std::function<void(int)>;
auto result = callable_v<Func, int>;
std::cout << "test 2 (should be 1) = " << result << std::endl;
}
{
using Func = std::function<int(int)>;
auto result = callable_v<Func, int>;
std::cout << "test 3 (should be 1) = " << result << std::endl;
}
std::getchar();
return EXIT_SUCCESS;
}
я использую компилятор, который поддерживает C++ 14.
3 ответов
сокращение использования std::result_of делать то, что вы хотите, может выглядеть следующим образом:
template <class T, class, class... Args>
struct callable: std::false_type {
};
template <class T, class... Args>
struct callable<T, decltype(std::result_of_t<T(Args...)>(), void()), Args...>:std::true_type {
};
template <class F, class... Args>
constexpr auto callable_v = callable<F, void, Args...>::value;
вы должны помнить, что тип возвращаемого result_of всегда является типом результата функции, которую вы передаете этому признаку по типу. Чтобы ваш sfinae работал, вам нужен метод, чтобы изменить этот тип на void в любой возможной ситуации. Вы можете сделать это, используя трюк с decltype (decltype(std::result_of_t<T(Args...)>(), void())).
Edit:
чтобы разработать поток из комментариев о возможных недостатках решения. The std::result_of_t<T(Args...)> type не должен быть оснащен непараметрическим конструктором по умолчанию, и поэтому sfinae может привести к ложному отрицательному результату callable_v для функции, которая приводит к такого рода типам. В комментариях я предложил обходной путь для проблемы, которая на самом деле не решает проблему или фактически генерирует новую один:
decltype(std::declval<std::result_of_t<T(Args...)>*>(), void())
целью этого кода было заставить sfinae работать, как в ранее предложенном решении, но в случае неконструктивных типов создать простой в построении (я думал) объект указателя на данный тип... В этом рассуждении я не принял во внимание типы, на которые нельзя создать указатель, например ссылки. Это снова может быть обходным путем с помощью некоторого дополнительного класса оболочки:
decltype(std::declval<std::tuple<std::result_of_t<T(Args...)>>*>(), void())
или загнивающий результат тип:
decltype(std::declval<std::decay_t<std::result_of_t<T(Args...)>>*>(), void())
но я думаю, что это может не стоить того, и, возможно, использование void_t на самом деле является более простым решением:
template <class...>
struct voider {
using type = void;
};
template <class... Args>
using void_t = typename voider<Args...>::type;
template <class T, class, class... Args>
struct callable: std::false_type {
};
template <class T, class... Args>
struct callable<T, void_t<std::result_of_t<T(Args...)>>, Args...>:std::true_type {
};
template <class F, class... Args>
constexpr auto callable_v = callable<F, void, Args...>::value;
вот как я бы подошел к этому:
namespace detail {
template<typename Func, typename...Params> static auto helper(int) ->
decltype((void)std::declval<Func>()(std::declval<Params>()...), std::true_type{});
template<typename Func, typename...Params> static std::false_type helper(...);
}
template<typename Func, typename... Params> struct callable:
decltype(detail::helper<Func, Params...>(0)){};
template <class F, class... Args> constexpr auto callable_v =
callable<F, Args...>::value;
это версия C++1Z для бедных людей is_callable, но он не обрабатывает указатели на членов. В остальном, думаю, все в порядке.
проблема с исходным кодом заключается в том, что вы используете пакет параметров в неразрешимом контексте
namespace impl
{
template <class F, class... Args>
struct callable : std::false_type
{
};
template <class F, class... Args>
struct callable<F, std::result_of_t<F(Args...)>> : std::true_type
^^^^^^^^^^^^^^^^^^^^^^^^^^^
{
};
}
на данный момент в исходном коде синтаксического анализа не может быть никакого способа, что std::result_of_t<Func, int> может дать другое возвращаемое значение, но позже в файле может быть другая специализация, как в следующем (очень извращенное) фрагмент
namespace std {
template <>
struct result_of<Func(int)> {
using type = double;
};
}
поэтому ваш компилятор должен проверить их все одновременно, прежде чем сможет забрать правильно.
это также причина, почему обходные пути, как
template< class... > using void_t = void;
namespace impl
{
template <typename...>
struct callable_args
{
};
template <class F, class Args, class = void>
struct callable : std::false_type
{
};
template <class F, class... Args>
struct callable<F, callable_args<Args...>, void_t<std::result_of_t<F(Args...)>>> : std::true_type
{
};
}
работа в вашем случае: они помогают компилятору решить зависимый тип как то, что всегда разрешает void. Помните, что приведенный выше код является решение и вы должны использовать is_callable (C++17) или изучите, как is_callable реализован и получить представление о его технических проблемах.