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
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75

#include <memory>
#include <vector>
#include <cstddef>
#include <iostream>


namespace fun {


template <typename T>
class slice {

    template <typename>
    friend slice<T> make_slice(std::size_t );

    using iter_type = typename std::vector<T>::iterator;

    public:
        slice(const slice &s): ptr(s.ptr), begin(s.begin), end(s.end) {}

        slice(std::size_t cap) {
            ptr = std::make_shared<std::vector<T>>(cap);
            ptr->reserve(cap);
            begin = ptr->begin();
            end = ptr->end();
        }

        slice<T> as_slice(std::size_t begin, std::size_t end) {
            return slice(*this, this->begin + begin, this->begin + end);
        }

        T& operator[](std::size_t idx) {
            return *(begin + idx);
        }

        slice<T> & operator=(slice<T> &b) {
            if(this != &b) {
                ptr = b.ptr;
                begin = b.begin;
                end = b.end;
            }
            return *this;
        }



    private:
        std::shared_ptr<std::vector<T>> ptr;
        iter_type begin;
        iter_type end;

        slice(const slice &s, iter_type b,  iter_type e) : ptr(s.ptr), begin(b), end(e) {}
};

template<typename T>
slice<T> make_slice(std::size_t cap) {
    return slice<T>(cap);
}

}


using namespace fun;

int main() {
    auto s = make_slice<int>(10); // s := make(int, 10)
    s[2] = 2;

    std::cout<<s[0] <<std::endl;
    auto s0 = s.as_slice(2,10); //s0 := s[2:10]
    std::cout <<s0[0] <<std::endl;
    return 0;
}

很粗糙的实现,没有异常,没有cap/len,但是意思到了。 实际上c++根本不需要slice,vector+shared_ptr足以。