使用 std：：span 的泛型函数无法编译

Question

我想制作一个接受std::span的isIn函数。

这是我的尝试：

#include <span>
template <typename T1, typename T2>
bool isIn(const T1& x, std::span<const T2> v)
{
for (const T2& e : v)
if (e == x)
return true;
return false;
}
// this one would work, but I want my function to be generic
/*bool isIn(int x, std::span<const int> v)
{
for (int e : v)
if (e == x)
return true;
return false;
}*/
int main()
{
const int v[] = {1, 2, 3, 4};
isIn(2, v); // I want this, but doesn't compile
//isIn(2, std::span<const int>(v)); // this works fine
}

正如你所看到的，我可以通过铸造来四处走动：

isIn(2, std::span<const int>(v));

但这很冗长，我想做这样的事情：

isIn(2, v);

有什么办法可以实现吗？

https://godbolt.org/z/czTs83

Answer 1

这里是您的代码的c++20版本。

首先，我们从两个概念开始；is_span和spannable:

template<class T>
concept is_span = requires(T& a) {
{ std::span(a) } -> std::same_as<T>;
};
template<class T>
concept spannable = requires(T& a) {
{ std::span(a) };
} && !is_span<T>;

某个spannable可以被推导成span而不是一个。

然后我们写两个重载：

constexpr bool isIn(const auto& x, is_span auto const& v)
{
for (const auto& e : v)
if (e == x)
return true;
return false;
}
constexpr bool isIn(const auto& x, spannable auto const& v)
{
return isIn(x, std::span(v));
}

使用新语法。

然后我们再添加一个过载：

template<std::size_t N>
constexpr bool isIn(const auto& x, auto const(& v)[N])
{
return isIn(x, std::span(v));
}

它允许这种美味的语法：

static_assert( isIn( 7, {1,2,3,4,5,6,7} ));

实例

现在你所要做的就是把它变成内野。

"；可悲的是"指

static_assert( isIn('', "hello") );

是真的，因为"hello"是在末尾包含''的数组。

template<class T>
constexpr bool isIn(const auto& x, std::initializer_list<T> il)
{
return isIn(x, std::span(il));
}
template<std::size_t N>
constexpr bool isIn(char x, char const(& v)[N])
{
return isIn(x, std::span(v, v+N-1));
}

活生生的例子。

Answer 2

模板扣减没有转换/提升，

所以CCD_ 9不能被推导为CCD_。

您可能仍然提供重载来自己进行转换(注意避免无限递归调用)：

template <typename T1, typename T2, std::size_t N>
bool isIn(const T1& x, std::span<const T2, N> v)
{
// return std::find(std::begin(v), std::end(v), x) != std::end(v);
for (const T2& e : v) {
if (e == x) {
return true;
}
}
return false;
}
template <typename T, typename C>
bool isIn(const T& x, const C&c)
{
return isIn(x, std::span(c)); // Use CTAD for the conversion.
}

但这里不需要std::span：

template <typename T, typename C>
bool isIn(const T& x, const C& c)
{
// return std::find(std::begin(c), std::end(c), x) != std::end(c);
for (const auto& e : c) {
if (e == x) {
return true;
}
}
return false;
}

Answer 3

在像以下这样的通用函数中不需要使用std::span：

template <typename T1, typename T2>
bool isIn(T1&& x, T2 &&v) // always use universal references
{ 
for (auto&& e : v)
if (e == x)
return true;
return false;
}
int main()
{
const int v[] = {1, 2, 3, 4};
isIn(2, v); // T2 is const &int[4]
isIn(2, std::span<const int>{v}); // T2 is span<const int>
isIn(2, std::list<int>(std::begin(v),std::end(v)) ); // T2 is list<int>
// but list cannot be a span!
isIn('l',"blablalba"); //works too, T2 is const &char[9]
std::string_view s = "blablalba";
isIn('l',s); // T2 is std::string_view&
}

这样，它将适用于定义了std:：begin和std:：end的任何类型。

Answer 4

这个实现涵盖了我的所有用例。我认为它可能对其他人有用：

#include <stdio.h>
#include <initializer_list>
#include <string_view>
template <typename T1, typename T2>
bool isIn(const T1& x, const T2 &v)
{ 
printf("genericn");
for (auto& e : v)
if (e == x)
return true;
return false;
}
bool isIn(char x, const char* v)
{
// NOTE: we have this specialization because we don't want to consider the null terminator
printf("strn");
return isIn(x, std::string_view(v));
}
template <typename T1, typename T2>
bool isIn(const T1& x, std::initializer_list<T2> v)
{ 
printf("initializer_listn");
for (auto& e : v)
if (e == x)
return true;
return false;
}
int main()
{
const int v[] = {1, 2, 3, 4};
isIn(2, v); // generic
isIn(2, {1, 2, 3, 4}); // initializer_list
isIn('l', "blabla"); // str
}

https://godbolt.org/z/d3nW73