Checking a member exists, possibly in a base class, C++11 version

by

Actually, things got much easier in C++11 thanks to the decltype and late return bindings machinery.

Now, it’s just simpler to use methods to test this:

// Culled by SFINAE if reserve does not exist or is not accessible
template <typename T>
constexpr auto has_reserve_method(T& t) -> decltype(t.reserve(0), bool()) {
  return true;
}

// Used as fallback when SFINAE culls the template method
constexpr bool has_reserve_method(...) { return false; }

You can then use this in a class for example:

template <typename T, bool b>
struct Reserver {
  static void apply(T& t, size_t n) { t.reserve(n); }
};

template <typename T>
struct Reserver <T, false> {
  static void apply(T& t, size_t n) {}
};

And you use it so:

template <typename T>
bool reserve(T& t, size_t n) {
  Reserver<T, has_reserve_method(t)>::apply(t, n);
  return has_reserve_method(t);
}

Or you can choose a enable_if method:

template <typename T>
auto reserve(T& t, size_t n) -> typename std::enable_if<has_reserve_method(t), bool>::type {
  t.reserve(n);
  return true;
}

template <typename T>
auto reserve(T& t, size_t n) -> typename std::enable_if<not has_reserve_method(t), bool>::type {
  return false;
}

Note that this switching things is actually not so easy. In general, it’s much easier when just SFINAE exist — and you just want to enable_if one method and not provide any fallback:

template <typename T>
auto reserve(T& t, size_t n) -> decltype(t.reserve(n), void()) {
  t.reserve(n);
}

If substitution fails, this method is removed from the list of possible overloads.

Note: thanks to the semantics of , (the comma operator) you can chain multiple expressions in decltype and only the last actually decides the type. Handy to check multiple operations.

More Related Contents:

  1. “What happened to my SFINAE” redux: conditional template class members?
  2. How can you iterate over the elements of an std::tuple?
  3. Creating an array initializer from a tuple or variadic template parameters
  4. Why is there not an std::is_struct type trait?
  5. check variadic templates parameters for uniqueness
  6. How to make generic computations over heterogeneous argument packs of a variadic template function?
  7. What do compilers do with compile-time branching?
  8. What is decltype with two arguments?
  9. Is it possible to determine if a type is a scoped enumeration type?
  10. void_t “can implement concepts”?
  11. Disambiguate overloaded member function pointer being passed as template parameter
  12. Which cannot be implemented without compiler hooks?
  13. C++11 “overloaded lambda” with variadic template and variable capture
  14. Check traits for all variadic template arguments
  15. TMP: how to generalize a Cartesian Product of Vectors?
  16. False positive with is_copy_constructible on vector
  17. What is the purpose of the “final” keyword in C++11 for functions?
  18. What’s the point of a final virtual function?
  19. C++11 is_same type trait for templates
  20. constexpr initialization of array to sort contents
  21. Generating one class member per variadic template argument
  22. Concatenate compile-time strings in a template at compile time?
  23. should std::common_type use std::decay?
  24. Reusing a moved container?
  25. std::bind a bound function
  26. What expressions yield a reference type when decltype is applied to them?
  27. How can I have multiple parameter packs in a variadic template?
  28. How to typedef a template class? [duplicate]
  29. Why the sequence-operation algorithms predicates are passed by copy?
  30. How to assert if a std::mutex is locked?

Leave a Comment