gsl：：span<T> 和 gsl：：span<const T> 重载不明确

gsl::span<T> and gsl::span<const T> overloads are ambigous

本文关键字：gt span gsl lt 不明确 重载 const      更新时间：2023-10-16

C++核心指南提倡使用span的做法。

问题在于常量和可变范围。这是我尝试做的：

auto foo(gsl::span<int>);         // 1st
auto foo(gsl::span<const int>);   // 2nd

但是如果没有明确的参数span转换/构造，就不能调用它们：

std::vector<int> v;
const std::vector<int> cv;
const std::vector<int>& crv = v;
// ambiguous
// want to call 1st
foo(v);
// ambiguous, although 1st is illegal (static_assert kicks in)
// want to call 2nd
foo(cv); // ambiguous
foo(crv); // ambiguous

处理这个问题的正确方法是什么？

这似乎是微不足道的，类似于const T&和T&过载，但事实并非如此（或者我只是没有看到它）。

只是为了在同一页面上，foo(gsl::span<int>{v})很麻烦，我想避免它，让来电者简单：foo(v)。

我概括了这个问题，但以防万一这是一个 XY 问题，这就是我实际尝试做的事情：

auto split(gsl::cstring_span<> str) -> std::vector<gsl::cstring_span<>>;
auto split(gsl::string_span<> str) -> std::vector<gsl::string_span<>>;

并希望可以用[const] char *、[const] string等参数来调用。

根据

P0122R1，span类的相关构造函数是：

template <class Container>
constexpr span(Container& cont);

所以不幸的是，你所有的 3 个例子都是格式错误的。第二个可以通过要求从重载解析中删除此构造函数来合法化，除非Container::value_type&可转换为span::value_type& Container与跨度兼容。

即使我们这样做，我也看不到允许数字 1 和 3 的方法，因为这两个重载只需要一个用户定义的隐式转换。

通常的解决方法是添加另一个级别：

template<class T>
auto foo( T && x ) { return foo_impl( as_span(std::forward<T>(x) ) ); }
auto foo_impl(gsl::span<int>);         // 1st
auto foo_impl(gsl::span<const int>);   // 2nd

请注意，as_span不在P0122R1中，但它在 GSL Microsoft中实现。它之所以有效，是因为它检查类型并返回span<typename Container::value_type>。

如 sbbabi 的回答所示as_span是解决span的一个不错的解决方案。但是没有as_string_span，这将解决我真正的问题。

这是我

的简单实现： 
template <class Char_t, gslx::size_t N>
auto as_basic_string_span(gsl::basic_string_span<Char_t, N> str)
    -> gsl::basic_string_span<Char_t, N>
{
    return str;
}
template <class Char_ptr_t>
auto as_basic_string_span(Char_ptr_t ptr)
    -> std::enable_if_t<
          stdx::is_pointer_v<Char_ptr_t>,
          gsl::basic_string_span<std::remove_pointer_t<Char_ptr_t>>>
{
    Expects(ptr != nullptr);
    return {ptr, gslx::size_cast(stdx::char_traits_length(ptr))};
}
template <class CharT, gslx::size_t N>
auto as_basic_string_span(stdx::c_array_t<CharT, N>& arr)
    -> gsl::basic_string_span<CharT, N - 1>
{
    Expects(N > 0 && arr[N - 1] == '');
    return arr;
}
template <class Char_t, class Traits, class Allocator>
auto as_basic_string_span(std::basic_string<Char_t, Traits, Allocator>& str)
    -> gsl::basic_string_span<Char_t>
{
    return {const_cast<Char_t*>(str.data()), gslx::size_cast(str.size())};
}
template <class Char_t, class Traits, class Allocator>
auto as_basic_string_span(
    const std::basic_string<Char_t, Traits, Allocator>& str)
    -> gsl::basic_string_span<const Char_t>
{
    return {str.data(), gslx::size_cast(str.size())};
}
template <class Char_t, class Traits, class Allocator>
auto as_basic_string_span(std::basic_string<Char_t, Traits, Allocator>&& str) =
    delete;

奖金as_const_basic_string_span ：

template <class Char_t, gslx::size_t N>
auto as_const_basic_string_span(gsl::basic_string_span<Char_t, N> str)
    -> gsl::basic_string_span<const Char_t, N>
{
    return str;
}
template <class... Args>
auto as_const_basic_string_span(Args&&... args)
    -> decltype(as_const_basic_string_span(
        as_basic_string_span(std::forward<Args>(args)...)))
{
    return as_const_basic_string_span(
        as_basic_string_span(std::forward<Args>(args)...));
}

和用法：

template <class CharT>
auto split(gsl::basic_string_span<CharT> str)
    -> std::vector<gsl::basic_string_span<CharT>>
template <class T>
auto split(T&& str)
{
    return split(as_basic_string_span(std::forward<T>(str)));
}
相关文章：