如何为序列容器和关联容器实现通用功能？

Question

我正在考虑编写一个既适用于序列容器又适用于关联容器的函数。有点像

 template<class C, class V = typename C::key_type>
 bool has_val(const C& c, const V& v)`

函数里面，我想

检查 class C 是否具有容器 class 的成员函数 const_iterator find(key_type) const，例如 set/map。
如果它不包含 find()，那么我们使用 std::find() 作为序列容器，例如 std::vector。

检查的最佳做法是什么，(1)？

如果我上面描述的不是最好的，请指教是否有更好的方法？

（不幸的是，我无法使用宏 FOLLY_create_member_invoker 访问较新的 Folly，但我确实有 FOLLY_CREATE_HAS_MEMBER_FN_TRAITS。不过我无法成功完成）

Answer 1

I am thinking to write a function that works both for sequence and associative container.

如果您知道传递给函数的是哪个容器/容器的特化，那么在其中应该非常明显。

我们可以通过以下is_specialization_of找到这个：

template <typename Type, template <typename...> class Container>
inline constexpr bool is_specialization_of = false;

template <template <typename...> class Container, typename... Args>
inline constexpr bool is_specialization_of<Container<Args...>, Container> = true;

接下来，您可以使用 if constexpr, (Since c++17) 并可以执行以下操作：

template<typename Container>
auto find_in_sequence_containers(const Container& container
    , typename Container::value_type const& val)
{
    return std::find(std::cbegin(container), std::cend(container), val);
}

template<typename Container>
auto find_in_associative_containers(const Container& container
    ,  typename Container::key_type const& key)
{
    return container.find(key);
}

template<typename Container, typename T2>
auto generic_find(const Container& container, T2 const& arg)
{
    if constexpr (is_specialization_of<Container, std::vector>)
    {
        return find_in_sequence_containers(container, arg);
    }
    if constexpr (is_specialization_of<Container, std::map>)
    {
        return find_in_associative_containers(container, arg);
    }
    // ... so on
}

通过这种方式，您可以避免检查传递的容器上的成员函数可用性（即find）。

(See an example code Online)

Answer 2

使用SFINAE检测是否使用c.find():

#include <algorithm>

template <class C, class V, typename = void>
constexpr inline bool use_mem_find = false;

template <class C, class V>
constexpr inline bool use_mem_find<C, V,
  std::void_t<decltype(std::declval<const C&>().find(std::declval<const V&>()))>> = true;

template<class C, class V> 
bool has_val(const C& c, const V& v) {
  auto end = std::end(c);
  if constexpr (use_mem_find<C, V>)
    return c.find(v) != end;
  else
    return std::find(std::begin(c), end, v) != end;
}

Demo.

如何为序列容器和关联容器实现通用功能？

How to implement a universal function for both sequence and associative container?

c++

templates

c++-standard-library

function-templates

c++17