span就是一个连续对象存储的观察者。类似std::string_view是string的观察者。
连续的存储，不一定是数组。例如：
|
1 2 3 4 5 6 7 8 |
zero(char (&arr) [10]); //10个元素的数组, sizeof(arr)==10*sizeof(char)==10 zero(char arr[]); //arr退化为指针, sizeof(arr)==sizeof(char*) zero(char *arr, size_t n); //处理任意含n个char的连续内存
void main(){ char* pc = new char[10]; zero(pc,10); //连续内存，但不是数组 } |
为了程序的复用性，我们一般使用zero(char* arr, size_t n);这种函数签名。
|
1 2 |
template<size_t N> void zero(char (&arr)[N]) ; |
这种模板形式虽然比只能处理char[10]这种类型的zero函数，适用性大一些，但是它仍不能处理广义上的连续char内存。
zero(char*arr, sizr_t n)的灵活性是有了，问题是用户（调用者）可能把n填错。例如：
|
1 2 |
char aa[10]; zero(aa,20); |
为了解决这个问题，我们需要写很繁琐的代码：
|
1 2 3 4 5 |
char aa[10]; std::array<char,10> bb;
zero(aa,sizeof(aa)/sizeof(aa[0])); zero(bb.data(),bb.size()); |
有了std::span, 我们可以：
|
1 2 3 4 5 6 7 8 9 10 |
void zero( std::span<char> sp ){ size_t n = sp.size(); sp[n-1]=0; //当数组越界时，仍可能引发事故。 }
char aa[10]; std::array<char,10> bb;
zero(aa); zero(bb); //简化，统一 |
我们可以手工粗陋的制作一个span类，虽然它不符合STL容器规范，但是可以看出主要核心骨架
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 |
// This file is a "Hello, world!" in C++ language by GCC for wandbox. #include <iostream> #include <cstdlib> #include <array>
template<class T> class span{ public: template<size_t N> span(T (&arr)[N]){ arr_ = arr; n_ = N; }
template<size_t N> span(std::array<T,N>& arr){ arr_ = arr.data(); n_ = N; }
span(T* arr,size_t n){ arr_ = arr; n_ = n; }
T* data(){ return arr_;} size_t size(){ return n_;}
private: T* arr_; size_t n_; };
void zero( span<char> sp ){
char* arr = sp.data(); size_t n = sp.size(); arr[n-1]=0; }
int main() { char aa[10]; std::array<char,10> bb;
size_t n=10; char* pc = new char[n]; zero(aa); zero(bb); zero({pc,n});
} |
