如何为序列和关联容器实现通用函数

Question

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

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

在功能内部，我想

1. 检查类C是否具有用于容器类(如set/map)的成员函数const_iterator find(key_type) const
2. 如果它不包含find()，那么我们将std::find()用于类似std::vector的序列容器

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

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

(不幸的是，我无法访问带有宏FOLLY_create_member_invoker的较新Folly，但我有FOLLY_CREATE_HAS_MEMBER_FN_TRAITS。不过，我无法成功通过)

Answer 1

使用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;
}

演示。

Answer 2

我正在考虑编写一个函数，该函数适用于序列和关联容器。

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

我们可以通过以下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(由于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)。

(请参阅联机示例代码)