c++中模板化的is_in()函数(检查数组是否包含字符串)

Question

我想做以下事情:

std::string b = "b";
is_in("a", { "a", "b", "c" });
is_in("d", { "a", "b", "c" });
is_in(b, { "a", "b", "c" }); // fails
is_in(b, std::array{ "a", "b", "c" });

使用模板

template<typename Element, typename Container>
bool is_in(const Element& e, const Container& c)
{
// https://stackoverflow.com/questions/20303821/how-to-check-if-string-is-in-array-of-strings
return std::find(std::begin(c), std::end(c), e) != std::end(c);
}
template<typename Element>
bool is_in(Element e, std::initializer_list<Element> l)
{
// return std::find(std::begin(l), std::end(l), e) != std::end(l);
return is_in<Element, std::initializer_list<Element>>(e, l);
}

但是我得到以下错误(使用GCC 9.3.0):

no matching function for call to ‘is_in(std::string&, <brace-enclosed initializer list>)’

有大的大脑模板的家伙有什么建议吗?

Answer 1

对于is_in(b, { "a", "b", "c" });，模板参数Element在第一个参数b上推导为std::string，在第二个参数{ "a", "b", "c" }上推导为const char*;它们不匹配。

您可以为is_in提供两个模板参数，例如

template<typename E1, typename E2>
bool is_in(E1 e, std::initializer_list<E2> l)
{
// return std::find(std::begin(l), std::end(l), e) != std::end(l);
return is_in<E1, std::initializer_list<E2>>(e, l);
}

或使用std::type_identity(自c++ 20;(在c++ 20之前的版本中，很容易编写一个函数来排除类型演绎中的第二个函数参数。

template<typename Element>
bool is_in(Element e, std::initializer_list<std::type_identity_t<Element>> l)
{
// return std::find(std::begin(l), std::end(l), e) != std::end(l);
return is_in<Element, std::initializer_list<Element>>(e, l);
}

Answer 2

另一种方法是在比较不匹配的字符串类型之前将它们转换为std::string。

#include <cassert>
#include <array>
#include <string>
// Help the compiler figure out to compare "unrelated" string types
namespace details
{
template<typename type_t>
struct compare_as
{
using type = type_t;
};
template<std::size_t N>
struct compare_as<char[N]>
{
using type = std::string;
};
template<>
struct compare_as<char*>
{
using type = std::string;
};
}
// template for "array" style parameters 
template<typename type_t, typename coll_t, std::size_t N>
constexpr auto is_in(const type_t& value, const coll_t(&values)[N])
{
for (const auto& v : values)
{
typename details::compare_as<coll_t>::type lhs{ v };
typename details::compare_as<type_t>::type rhs{ value };
if (lhs == rhs) return true;
}
return false;
}
// template for containers
template<typename type_t, typename coll_t>
constexpr auto is_in(const type_t& value, const coll_t& values)
{
for (const auto& v : values)
{
typename details::compare_as<type_t>::type lhs{ v };
typename details::compare_as<type_t>::type rhs{ value };
if (lhs == rhs) return true;
}
return false;
}
int main()
{
// for non-string types compile time checking is possible
static_assert(is_in(1, { 1,2,3 }));
std::string b = "b";
assert(is_in("a", { "a", "b", "c" }));
assert(!is_in("d", { "a", "b", "c" }));
assert(is_in(b, { "a", "b", "c" }));
assert(is_in(b, std::array{ "a", "b", "c" }));
}