How can I create a template class that can choose special container for T?

Question

How can I create a template class that can understand if type T is hashable or not, and if it is then use std::unodered_set to collect elements of type T?. Otherwise, I want it to use std::set.

This class have the same simple methods as above sets such as insert(), find() and so on.

template<class T>
class MySet {
public:
    MySet() {}
    bool find() {
    //some code here

I check if type has operator() to get information about its "hashability". For this purpose I use the following construction, which I found on this site:

template<typename T>
class HasHash {
    typedef char one;
    typedef long two;

    template<typename C>
    static one test(decltype(&C::operator()));

    template<typename C>
    static two test(...);

public:
    enum {
        value = sizeof(test<T>(0)) == sizeof(size_t)
    };
};

And get is hashable or not (true or false) by typing:

HasHash<HashableType>::value

There is no way for me to use boost library.

Would [this](https://stackoverflow.com/questions/12753997/check-if-type-is-hashable) solve your problem? — einpoklum, Mar 16 '18 at 23:58
I have seen this post and I have already solved that part of my problem. The question is how to create class that will be using different `sets` for different types. — InFamous X, Mar 17 '18 at 00:25
How about `std::conditional_t, std::unordered_set, std::set>`? — einpoklum, Mar 17 '18 at 00:43

einpoklum · Answer 1 · 2018-03-17T12:17:40.033

5

If you have a is_hashable<T> type trait (e.g. your HasHash), then you can use std::conditional, like so:

template <typename T>
std::conditional<is_hashable<T>::value, std::unordered_set<T>, std::set<T>>::type

or if you're using C++17, it could be simplified to:

template <typename T>
inline constexpr bool is_hashable_v = is_hashable<T>::value;

template <typename T>
std::conditional_t<is_hashable_v<T>, std::unordered_set<T>, std::set<T>>;

(assuming you've also implemented the _v version of the trait).

For some additional discussion regarding determining hashability, this is also interesting:

Check if type is hashable

here on the site.

edited Mar 17 '18 at 12:17

answered Mar 17 '18 at 00:50

einpoklum

118,144
57
340
684

Thank you, but I am really new at metaprogramming and don't know how to implement this to my problem. I need to make a class with some container in it, but there is no way to use the both `std::set` and `std::unodered_set`. And how can I use `std::conditional` to solve this problem? – InFamous X Mar 17 '18 at 12:17
Oh, I forget to mention that type `T` might don't have both operators `==` and (`<` or `>`). For this type I need to use `std::unordered_set`, and I am afraid that `std::conditional` might not help me. – InFamous X Mar 17 '18 at 12:47

SU3 · Accepted Answer · 2018-03-19T20:38:13.670

Here's a full working example, assuming you are using std::hash.

#include <iostream>
#include <set>
#include <unordered_set>
#include <type_traits>
#include <functional>

using std::cout;
using std::endl;

template <typename...> using void_t = void;

template <typename, typename = void>
struct is_hashable : std::false_type { };
template <typename T>
struct is_hashable<T, void_t<decltype(std::hash<T>{})>> : std::true_type { };

template <typename T>
using set = typename std::conditional<
  is_hashable<T>::value, std::unordered_set<T>, std::set<T>
>::type;

template <typename T> void test() { cout << __PRETTY_FUNCTION__ << endl; }

struct dummy_type { };

int main(int argc, char* argv[]) {
  cout << std::boolalpha;
  cout << is_hashable<int>::value << endl;
  cout << is_hashable<dummy_type>::value << endl;

  test<set<int>>();
  test<set<dummy_type>>();
}

The output should be similar to

true
false
void test() [with T = std::unordered_set<int, std::hash<int>, std::equal_to<int>, std::allocator<int> >]
void test() [with T = std::set<dummy_type, std::less<dummy_type>, std::allocator<dummy_type> >]

Edit: is_hashable specialization can also be done without the use of void_t, like this:

template <typename T>
struct is_hashable<T, decltype(std::hash<T>{},void())> : std::true_type { };

Thank you! This is what I need and even more – InFamous X Mar 19 '18 at 20:29 — InFamous X, Mar 19 '18 at 20:29

How can I create a template class that can choose special container for T?

2 Answers2