C++20 std::span

span就是一个连续对象存储的观察者。类似std::string_view是string的观察者。
连续的存储,不一定是数组。例如:

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);这种函数签名。
 

template
void zero(char (&arr)[N]) ;

这种模板形式虽然比只能处理char[10]这种类型的zero函数,适用性大一些,但是它仍不能处理广义上的连续char内存。
zero(char*arr, sizr_t n)的灵活性是有了,问题是用户(调用者)可能把n填错。例如:

char aa[10];
zero(aa,20);

为了解决这个问题,我们需要写很繁琐的代码:

char aa[10];
std::array bb;

zero(aa,sizeof(aa)/sizeof(aa[0]));
zero(bb.data(),bb.size());

有了std::span, 我们可以:

void zero( std::span sp ){
    size_t n = sp.size();
    sp[n-1]=0; //当数组越界时,仍可能引发事故。
}

char aa[10];
std::array bb;
  
zero(aa);
zero(bb);  //简化,统一

我们可以手工粗陋的制作一个span类,虽然它不符合STL容器规范,但是可以看出主要核心骨架

// This file is a "Hello, world!" in C++ language by GCC for wandbox.
#include 
#include 
#include 

template
class span{
public:
    template
    span(T (&arr)[N]){
        arr_ = arr;
        n_ = N;
    }
    
    template
    span(std::array& 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 sp ){
    
    char* arr = sp.data();
    size_t n = sp.size();
    arr[n-1]=0;
}

int main()
{
    char aa[10];
    std::array bb;
    
    size_t n=10;
    char* pc = new char[n];

      
    zero(aa);
    zero(bb);
    zero({pc,n});
   
}

 

你可能感兴趣的:(就你不知道)