Как узнать, содержит ли кортеж тип?
Предположим, что я хочу создать гетерогенный контейнер с компиляцией уникальных типов из некоторой последовательности неисторических типов. Для этого мне нужно выполнить итерацию по типу источника (какой-то tuple) и проверить, существует ли каждый тип в моем "уникальном" кортеже.
Мой вопрос: Как проверить, содержит ли кортеж (или контейнер boost::fusion) тип?
Я открыт для использования STL или boost.
Ответы
Ответ 1
#include <tuple>
#include <type_traits>
template <typename T, typename Tuple>
struct has_type;
template <typename T>
struct has_type<T, std::tuple<>> : std::false_type {};
template <typename T, typename U, typename... Ts>
struct has_type<T, std::tuple<U, Ts...>> : has_type<T, std::tuple<Ts...>> {};
template <typename T, typename... Ts>
struct has_type<T, std::tuple<T, Ts...>> : std::true_type {};
DEMO
И дополнительный псевдоним, если сам признак должен быть std::true_type или std::false_type:
template <typename T, typename Tuple>
using tuple_contains_type = typename has_type<T, Tuple>::type;
Ответ 2
Мне действительно понадобилось что-то подобное для проекта. Это было мое решение:
#include <tuple>
#include <type_traits>
namespace detail {
struct null { };
}
template <typename T, typename Tuple>
struct tuple_contains;
template <typename T, typename... Ts>
struct tuple_contains<T, std::tuple<Ts...>> :
std::integral_constant<
bool,
!std::is_same<
std::tuple<typename std::conditional<std::is_same<T, Ts>::value, detail::null, Ts>::type...>,
std::tuple<Ts...>
>::value
>
{ };
Основным преимуществом этого метода является то, что он один экземпляр, не требуется рекурсия.
Ответ 3
Поскольку никто не размещал его, я добавляю еще одно решение, основанное на трюке bool, о котором я узнал здесь, в SO:
#include<type_traits>
#include<tuple>
template<bool...>
struct check {};
template<typename U, typename... T>
constexpr bool contains(std::tuple<T...>) {
return not std::is_same<
check<false, std::is_same<U, T>::value...>,
check<std::is_same<U, T>::value..., false>
>::value;
}
int main() {
static_assert(contains<int>(std::tuple<int, char, double>{}), "!");
static_assert(contains<char>(std::tuple<int, char, double>{}), "!");
static_assert(contains<double>(std::tuple<int, char, double>{}), "!");
static_assert(not contains<float>(std::tuple<int, char, double>{}), "!");
static_assert(not contains<void>(std::tuple<int, char, double>{}), "!");
}
С точки зрения производительности компиляции это медленнее, чем принятое решение , но стоит упомянуть его.
В С++ 14 было бы еще проще писать. Стандартный шаблон предлагает уже все, что вам нужно сделать в заголовке <utility>:
template<typename U, typename... T>
constexpr auto contains(std::tuple<T...>) {
return not std::is_same<
std::integer_sequence<bool, false, std::is_same<U, T>::value...>,
std::integer_sequence<bool, std::is_same<U, T>::value..., false>
>::value;
}
Это далеко не концептуально из того, что std::get делает (доступно с С++ 14 для типов), но обратите внимание, что последний не удается скомпилировать, если тип U присутствует более одного раза в T.... < ш > Если он соответствует вашим требованиям, в основном зависит от реальной проблемы.
Ответ 4
Вот версия, которая не рекурсивно создает экземпляр шаблона для проверки подходящего типа. Вместо этого он использует SFINAE с мета-программированием на основе индексов:
#include <type_traits>
#include <tuple>
template <std::size_t... Indices>
struct index_sequence {
typedef index_sequence<Indices..., sizeof...(Indices)> next;
};
template <std::size_t Start>
struct make_index_sequence {
typedef typename make_index_sequence<Start - 1>::type::next type;
};
template <>
struct make_index_sequence<0> {
typedef index_sequence<> type;
};
template <int n>
using make_index_sequence_t = typename make_index_sequence<n>::type;
template <typename Value, typename Sequence>
struct lookup;
template <typename Value, std::size_t... index>
struct lookup<Value, index_sequence<index...>>
{
private:
struct null;
template <typename... Args>
static std::false_type
apply(std::conditional_t<std::is_convertible<Args, Value>::value, null, Args>...);
template <typename...>
static std::true_type apply(...);
template <typename... Args>
static auto apply_helper(Args&&...) ->
decltype(apply<std::remove_reference_t<Args>...>(std::declval<Args>()...));
public:
template <typename Tuple>
using value = decltype(
apply_helper(
std::declval<
typename std::tuple_element<index, Tuple>::type
>()...
)
);
};
template <typename Value, typename Tuple>
using has_type = decltype(
typename lookup<Value,
make_index_sequence_t<std::tuple_size<Tuple>::value>
>::template value<Tuple>{}
);
Live Demo
Ответ 5
В С++ 17 вы можете сделать это следующим образом:
template <typename T, typename Tuple>
struct has_type;
template <typename T, typename... Us>
struct has_type<T, std::tuple<Us...>> : std::disjunction<std::is_same<T, Us>...> {};
В С++ 11 вам нужно перевернуть свой собственный or/disjunction. Здесь полная версия С++ 11 с тестами:
#include <tuple>
#include <type_traits>
template<typename... Conds>
struct or_ : std::false_type {};
template<typename Cond, typename... Conds>
struct or_<Cond, Conds...> : std::conditional<Cond::value, std::true_type, or_<Conds...>>::type
{};
/*
// C++17 version:
template<class... B>
using or_ = std::disjunction<B...>;
*/
template <typename T, typename Tuple>
struct has_type;
template <typename T, typename... Us>
struct has_type<T, std::tuple<Us...>> : or_<std::is_same<T, Us>...> {};
// Tests
static_assert(has_type<int, std::tuple<>>::value == false, "test");
static_assert(has_type<int, std::tuple<int>>::value == true, "test");
static_assert(has_type<int, std::tuple<float>>::value == false, "test");
static_assert(has_type<int, std::tuple<float, int>>::value == true, "test");
static_assert(has_type<int, std::tuple<int, float>>::value == true, "test");
static_assert(has_type<int, std::tuple<char, float, int>>::value == true, "test");
static_assert(has_type<int, std::tuple<char, float, bool>>::value == false, "test");
static_assert(has_type<const int, std::tuple<int>>::value == false, "test"); // we're using is_same so cv matters
static_assert(has_type<int, std::tuple<const int>>::value == false, "test"); // we're using is_same so cv matters
Ответ 6
Поскольку вы попросили об этом, введите boost::mpl версию:
#include <boost/mpl/unique.hpp>
#include <boost/mpl/sort.hpp>
#include <boost/mpl/vector.hpp>
#include <boost/type_traits/is_same.hpp>
using namespace boost;
template<typename Seq>
struct unique_concat :
mpl::unique<typename mpl::sort<Seq, is_same<mpl::_1,mpl::_2>>::type,
is_same<mpl::_1,mpl::_2>> {};
template<typename T>
struct print;
int main()
{
typedef mpl::vector<int, float, float, char, int, double, int> input;
print<unique_concat<input>::type> asdf;
return 0;
}
