如何制作跨度的跨度

Question

>C++20std::span是一个非常好的编程界面。但是似乎没有一种简单的方法来拥有跨度。这是我正在尝试做的：

#include <iostream>
#include <span>
#include <string>
#include <vector>
void print(std::span<std::span<wchar_t>> matrix) {
for (auto const& str : matrix) {
for (auto const ch : str) {
std::wcout << ch;
}
std::wcout << 'n';
}
}
int main() {
std::vector<std::wstring> vec = {L"Cool", L"Cool", L"Cool"};
print(vec);
}

这不会编译。我该怎么做这样的事情？

Answer 1

为什么不使用概念呢？

#include <iostream>
#include <string>
#include <vector>
#include <ranges>
template <class R, class T>
concept Matrix = 
std::convertible_to<
std::ranges::range_reference_t<std::ranges::range_reference_t<R>>,
T>;
void print(Matrix<wchar_t> auto const& matrix) {
for (auto const& str : matrix) {
for (auto const ch : str) {
std::wcout << ch;
}
std::wcout << 'n';
}
}
int main() {
std::vector<std::wstring> vec = {L"Cool", L"Cool", L"Cool"};
print(vec);
}

godbolt.org

_{感谢 Barry 使用标准范围库提出上述简化概念。}

Answer 2

只需使用模板打印任何包含std::wstring或std::wstring_view的容器类型(为了演示而有两个任意类型限制;根据需要轻松调整或删除这些限制)

我更喜欢坚持使用更普遍可读的代码(C++"概念"非常先进，没有被广泛理解)。为什么不直接使用这个简单的模板？

template <typename T>
void print(const T& matrix) {
for (auto const& str : matrix) {
for (auto const ch : str) {
std::wcout << ch;
}
std::wcout << 'n';
}
}

作为奖励，添加此static_assert来检查类型并确保仅传入std::wstring或std::wstring_view字符串类型，例如(根据需要根据需要修改或删除静态断言)：

static_assert(std::is_same_v<decltype(str), const std::wstring&> || 
std::is_same_v<decltype(str), const std::wstring_view&>,
"Only strings of `std::wstring` or `std::wstring_view` are "
"allowed!");

现在，您有了这个更好版本的print()函数模板：

template <typename T>
void print(const T& matrix) {
for (auto const& str : matrix) {
static_assert(std::is_same_v<decltype(str), const std::wstring&> || 
std::is_same_v<decltype(str), const std::wstring_view&>,
"Only strings of `std::wstring` or `std::wstring_view` are "
"allowed!");
for (auto const ch : str) {
std::wcout << ch;
}
std::wcout << 'n';
}
}

但是，auto的第二次用法不是必需的，也没有增加任何价值(它只是混淆了事情)，所以让我们删除它，并使用它：

for (wchar_t const ch : str) {

auto的第一种用法很好，因为它可能是多种类型，因此需要它。

(注意：如果您确实需要在此处处理其他类型的字符，请忽略我在这里所说的内容，wchar_t更改回auto。这由您决定。

现在，我们有了printf()函数模板的最终版本：

template <typename T>
void print(const T& matrix) {
for (auto const& str : matrix) {
static_assert(std::is_same_v<decltype(str), const std::wstring&> || 
std::is_same_v<decltype(str), const std::wstring_view&>,
"Only strings of `std::wstring` or `std::wstring_view` are "
"allowed!");
for (wchar_t const ch : str) {
std::wcout << ch;
}
std::wcout << 'n';
}
}

看来您的目标是能够使用自定义print()功能打印任何包含宽字符文本的容器类型，不是吗？

您似乎将其称为"矩阵"，其中容器中的外部元素是一个字符串，每个字符串的内部元素是一个宽字符 (wchar)。

如果是这种情况，以下模板就可以正常工作。我只是简单地改变了这个：

void print(std::span<std::span<wchar_t>> matrix) {

对此：

template <typename T>
void print(const T& matrix) {

。然后我补充说：

1. a 依赖于 A)std::is_same_v<>(与std::is_same<>::value相同)和 B)decltype()说明符的static_assert，以确保只传入std::wstring或std::wstring_view字符串类型，以及
2. main()中还有一些测试打印，包括std::vector<std::wstring>和std::vector<std::wstring_view>的测试打印，以及链表：std::list<std::wstring_view>和无序集合(哈希集)：std::unordered_set<std::wstring>。

下面是整个代码和print()函数模板。联机运行此代码：https://godbolt.org/z/TabW43Yjf。

#include <iostream>
#include <list> // added for demo purposes to print a linked list in main()
// #include <span> // not needed
#include <string>
#include <type_traits> // added to check types and aid with static asserts
#include <unordered_set>
#include <vector>
template <typename T>
void print(const T& matrix) {
for (auto const& str : matrix) {
static_assert(std::is_same_v<decltype(str), const std::wstring&> || 
std::is_same_v<decltype(str), const std::wstring_view&>,
"Only strings of `std::wstring` or `std::wstring_view` are "
"allowed!");
for (wchar_t const ch : str) {
std::wcout << ch;
}
std::wcout << 'n';
}
}
int main() {
std::vector<std::wstring> vec1 = {L"Cool1", L"Cool2", L"Cool3"};
std::vector<std::wstring_view> vec2 = {L"Hey1", L"Hey2", L"Hey3"};
std::list<std::wstring_view> list1 = {L"You1", L"You2", L"You3"};
std::unordered_set<std::wstring> set1 = {L"There1", L"There2", L"There3"};
print(vec1);
print(vec2);
print(list1);
print(set1);
// Compile-time error due to the std::is_same_v<> usage in the static_assert 
// above!
// std::vector<std::string> vec3 = {"hey", "you"};
// print(vec3);
}

示例输出：

Cool1
Cool2
Cool3
Hey1
Hey2
Hey3
You1
You2
You3
There3
There2
There1

如果您只想打印std::vector<std::wstring>和std::vector<std::wstring_view>类型，这里有一个更有限的模板(同样，为了演示，这是两个任意类型限制;根据需要轻松调整或删除这些限制)：

只需在上面的模板中替换它：

template <typename T>
void print(const T& matrix) {

有了这个，强制它只接受std::vector<>容器类型(const T&上面的更改到下面的const std::vector<T>&，就是全部)：

template <typename T>
void print(const std::vector<T>& matrix) {

然后，添加一个static_assert以确保向量内的类型是std::wstring或std::wstring_view，根据需要。

完整代码如下。在这里在线运行：https://godbolt.org/z/qjhqq647M。

#include <iostream>
// #include <span> // not needed
#include <string>
#include <type_traits>
#include <vector>
template <typename T>
void print(const std::vector<T>& matrix) {
static_assert(std::is_same_v<T, std::wstring> || 
std::is_same_v<T, std::wstring_view>,
"Only vectors of `std::wstring` or `std::wstring_view` are allowed!");
for (auto const& str : matrix) {
for (wchar_t const ch : str) {
std::wcout << ch;
}
std::wcout << 'n';
}
}
int main() {
std::vector<std::wstring> vec1 = {L"Cool1", L"Cool2", L"Cool3"};
std::vector<std::wstring_view> vec2 = {L"Hey1", L"Hey2", L"Hey3"};
print(vec1);
print(vec2);
// Compile-time error due to the std::is_same_v<> usage in the static_assert 
// above!
// std::vector<std::string> vec3 = {"hey", "you"};
// print(vec3);
}

为什么跨度不起作用：

std::span<T>本质上只是一个结构，其中包含指向连续内存块的指针。 Cppreference.com 状态(着重号另加)：

类模板范围描述一个对象，该对象可以引用连续的对象序列，序列的第一个元素位于位置 0。

正如我在关于跨度的其他答案中所解释的那样(什么是"跨度"，我什么时候应该使用一个？)，它可能看起来像这样：

template <typename T>
struct span
{
T * ptr_to_array;   // pointer to a contiguous C-style array of data
// (which memory is NOT allocated or deallocated 
// by the span)
std::size_t length; // number of elements in the array
// Plus a bunch of constructors and convenience accessor methods here
}

然而，并非所有C++容器类型都存储在连续内存中，例如链表(std::list和std::forward_list)，因此它们不能放在一个范围中。

一般来说，span 是 C++ 中的包装器，用于包装 C 样式的数组，在一个变量中捕获指向其连续内存块的指针，并在另一个变量中捕获它们的长度。这样，您可以将函数原型替换为两个输入参数，如下所示：

void do_stuff(T *ptr_to_data, std::size_t num_elements) {}
// OR (the const form)
void do_stuff(const T *ptr_to_data, std::size_t num_elements) {}

使用带有一个输入参数的原型，如下所示：

void do_stuff(std::span<T> data) {}
// OR (the const form)
void do_stuff(const std::span<T> data) {}

正如@mcilloni在这里的评论中所说。

引用：

1. 划痕工作：
   1. https://godbolt.org/z/s99dnzj8z
   2. https://godbolt.org/z/33vzTM787
2. [我的回答]什么是"跨度"，我应该什么时候使用？
3. https://www.learncpp.com/cpp-tutorial/an-introduction-to-stdstring_view/- 很好地阅读什么是std::string_view，何时和为什么使用它以及如何使用它。它还涵盖了它的一些细微差别、局限性和缺点。
4. https://en.cppreference.com/w/cpp/container/span
5. https://en.cppreference.com/w/cpp/types/is_same
6. https://en.cppreference.com/w/cpp/header/type_traits
**
7. ***[我的答案--非常有用--我引用它以记住如何在编译时使用static_assert(std::is_same_v<decltype(var), some_type>, "some msg");静态检查类型 ] 使用static_assert检查传递给宏的类型

Answer 3

更新：尽管看到它以来投了反对票，但我还是把答案留在下面，它下面的评论也有价值，但这是我刚刚发布的一个不同的答案，我认为它有价值和优点。

---

我根本不理解在这里使用跨度的愿望(如果我遗漏了什么，请帮助我理解)，因为跨度的目的是包装和"C++化"(这有时已经是一种有争议的做法)一个 C 风格的数组。

为什么不直接改变这个：

void print(std::span<std::span<wchar_t>> matrix) {

对此？

void print(std::vector<std::wstring> matrix) {

现在代码工作得很好(在 Godbolt 上运行)：

#include <iostream>
// #include <span> // not needed
#include <string>
#include <vector>
void print(std::vector<std::wstring> matrix) {
for (auto const& str : matrix) {
for (auto const ch : str) {
std::wcout << ch;
}
std::wcout << 'n';
}
}
int main() {
std::vector<std::wstring> vec = {L"Cool", L"Cool", L"Cool"};
print(vec);
}

这是输出，如 Godbolt 所示。请注意，文本 (Cool Cool Cool) 打印得很好：

ASM generation compiler returned: 0
Execution build compiler returned: 0
Program returned: 0
Cool
Cool
Cool