go语言中的slice

package main;

import "fmt"

func main() {
        //slice本身不是数组，指向底层的数组
        //作为变长数组的替换方案
        //slice是引用类型

        //声明一个slice，这里不需要指定长度
        var a []int;

        //创建一个数组
        var b = [10]int{1, 2, 3, 4, 5, 6, 7, 8, 9, 10};

        //通过数组来创建slice
        c := b[1:len(b)];
        //同上，简写
        d := b[1:];
        //从下标2开始，到4结束，不包括下标4的元素
        e := b[2:4];
        //从数组开始，取3个
        f := b[:3];

        //通过make创建slice
        //长度为3，容量为10的slice
        g := make([]int, 3, 10);

        h := []byte{'a', 'b', 'c', 'd', 'e', 'f', 'g'};
        i := h[2:5];
        //注意这里的索引是相对i的索引，i现在是['c', 'd', 'e']
        j := i[1:3];
        //注意这里6已经超过了i的cap容量，会报错
        //j := i[1:6];

        //在slice的尾部追加元素
        k := make([]int, 3, 6);
        fmt.Printf("%p %v\n", &k, k);
        k = append(k, 1, 2, 3);
        fmt.Printf("%p %v\n", &k, k);
        //这里当追加的元素超过了slice的cap时，会重新分配地址，并把值拷贝
        k = append(k, 4, 5, 6);
        fmt.Printf("%p %v\n", &k, k);

        //slice是引用类型，修改某一个slice的值，其他也相应改变
        m := []int{1, 2, 3, 4, 5};
        l := m[2:5];
        n := m[1:4];
        fmt.Println(m, l, n);
        //改变l中的值，m,n中也相应改变
        l[0] = 6;
        fmt.Println(m, l, n);

        //如果当slice发生地址重新分配后，那相应改变是不生效的
        o := []int{1, 2, 3, 4, 5};
        p := o[2:5];
        q := o[1:4];
        fmt.Println(o, p, q);
        //在改变p元素值之前，我们让q发生地址重新分配
        q = append(q, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1);
        //再改变p的值，这时q的值不会发生改变，因为它已经指向新的地址
        p[0] = 6;
        fmt.Println(o, p, q);

        //copy时以长度短的为准
        r := []int{1, 2, 3, 4, 5};
        s := []int{6, 7, 8};
        //这里只会把s中的6,7,8拷贝到r中的1,2,3
        copy(r, s);
        fmt.Println(r, s);

        fmt.Println(a);
        fmt.Println(b);
        fmt.Println(c);
        fmt.Println(d);
        fmt.Println(e);
        fmt.Println(f);
        fmt.Println(g, len(g), cap(g));
        fmt.Println(string(h));
        fmt.Println(string(i), cap(i));
        fmt.Println(string(j), cap(j));
}