How do I find out if a tuple contains a type?

by 
#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

And an additional alias, if the trait itself should be std::true_type or std::false_type :

template <typename T, typename Tuple>
using tuple_contains_type = typename has_type<T, Tuple>::type;

More Related Contents:

  1. What are Aggregates and PODs and how/why are they special?
  2. Why should I use a pointer rather than the object itself?
  3. When should I use std::thread::detach?
  4. Why is `std::move` named `std::move`?
  5. Passing a std::array of unknown size to a function
  6. Outputting Date and Time in C++ using std::chrono
  7. What’s a use case for overloading member functions on reference qualifiers?
  8. Move constructor for std::mutex
  9. std::unique_lock or std::lock_guard?
  10. What are the differences between -std=c++11 and -std=gnu++11?
  11. Setting vector elements in range-based for loop [duplicate]
  12. what is the best modern c++ approach to construct and manipulate a 2d array [closed]
  13. std::shared_ptr initialization: make_shared() vs shared_ptr(new Foo) [duplicate]
  14. Is C++11’s long long really at least 64 bits?
  15. Can compiler generate std::move for a last use of lvalue automatically?
  16. constexpr function parameters as template arguments
  17. Can the point-of-instantiation be delayed until the end of the translation unit?
  18. C++ When is it OK to extend the `std` namespace?
  19. How to create timer events using C++ 11?
  20. How to pass a template function in a template argument list
  21. Is the Empty Base Class Optimization now a mandatory optimization (at least for standard-layout classes)?
  22. Why not to inherit from std::allocator
  23. Why does C++11 have `make_shared` but not `make_unique` [duplicate]
  24. stoi and std::to_string on mingw 4.7.1 [duplicate]
  25. reinterpret_cast between char* and std::uint8_t* – safe?
  26. Check if a type is from a particular namespace
  27. How does =delete on destructor prevent stack allocation?
  28. C++11 ‘native_handle’ is not a member of ‘std::this_thread’
  29. Does ‘auto’ type assignments of a pointer in c++11 require ‘*’?
  30. Why can’t C++11 move a noncopyable functor to a std::function?

Leave a Comment