切片

[]int

[]interface{}

// NewSlice returns the slice Type with element type elem.
func NewSlice(elem *Type) *Type {
    if t := elem.cache.slice; t != nil {
        if t.Elem() != elem {
            base.Fatalf("elem mismatch")
        }
        if elem.HasTParam() != t.HasTParam() || elem.HasShape() != t.HasShape() {
            base.Fatalf("Incorrect HasTParam/HasShape flag for cached slice type")
        }
        return t
    }

    t := newType(TSLICE)
    t.extra = Slice{Elem: elem}
    elem.cache.slice = t
    if elem.HasTParam() {
        t.SetHasTParam(true)
    }
    if elem.HasShape() {
        t.SetHasShape(true)
    }
    return t
}

// A Type represents a Go type.
//
// There may be multiple unnamed types with identical structure. However, there must
// be a unique Type object for each unique named (defined) type. After noding, a
// package-level type can be looked up by building its unique symbol sym (sym =
// package.Lookup(name)) and checking sym.Def. If sym.Def is non-nil, the type
// already exists at package scope and is available at sym.Def.(*ir.Name).Type().
// Local types (which may have the same name as a package-level type) are
// distinguished by the value of vargen.
type Type struct {
    // extra contains extra etype-specific fields.
    // As an optimization, those etype-specific structs which contain exactly
    // one pointer-shaped field are stored as values rather than pointers when possible.
    //
    // TMAP: *Map
    // TFORW: *Forward
    // TFUNC: *Func
    // TSTRUCT: *Struct
    // TINTER: *Interface
    // TFUNCARGS: FuncArgs
    // TCHANARGS: ChanArgs
    // TCHAN: *Chan
    // TPTR: Ptr
    // TARRAY: *Array
    // TSLICE: Slice
    // TSSA: string
    // TTYPEPARAM:  *Typeparam
    // TUNION: *Union
    extra interface{}

    // width is the width of this Type in bytes.
    width int64 // valid if Align > 0

    // list of base methods (excluding embedding)
    methods Fields
    // list of all methods (including embedding)
    allMethods Fields

    // canonical OTYPE node for a named type (should be an ir.Name node with same sym)
    obj Object
    // the underlying type (type literal or predeclared type) for a defined type
    underlying *Type

    // Cache of composite types, with this type being the element type.
    cache struct {
        ptr   *Type // *T, or nil
        slice *Type // []T, or nil
    }

    vargen int32 // unique name for OTYPE/ONAME

    kind  Kind  // kind of type
    align uint8 // the required alignment of this type, in bytes (0 means Width and Align have not yet been computed)

    flags bitset8

    // For defined (named) generic types, a pointer to the list of type params
    // (in order) of this type that need to be instantiated. For instantiated
    // generic types, this is the targs used to instantiate them. These targs
    // may be typeparams (for re-instantiated types such as Value[T2]) or
    // concrete types (for fully instantiated types such as Value[int]).
    // rparams is only set for named types that are generic or are fully
    // instantiated from a generic type, and is otherwise set to nil.
    // TODO(danscales): choose a better name.
    rparams *[]*Type

    // For an instantiated generic type, the base generic type.
    // This backpointer is useful, because the base type is the type that has
    // the method bodies.
    origType *Type
}

// Slice contains Type fields specific to slice types.
type Slice struct {
    Elem *Type // element type
}

// SliceHeader is the runtime representation of a slice.
// It cannot be used safely or portably and its representation may
// change in a later release.
// Moreover, the Data field is not sufficient to guarantee the data
// it references will not be garbage collected, so programs must keep
// a separate, correctly typed pointer to the underlying data.
//
// In new code, use unsafe.Slice or unsafe.SliceData instead.
type SliceHeader struct {
    Data uintptr
    Len  int
    Cap  int
}

package main

import "fmt"

func main() {
    arr := [3]int{1, 2, 3}
    slice := arr[0:1]
    fmt.Println(slice)
}

v1 (?) = InitMem <mem>
v2 (?) = SP <uintptr>
v3 (?) = SB <uintptr>
v4 (?) = Addr <*uint8> {type:[3]int} v3
v5 (+6) = StaticLECall <*[3]int,mem> {AuxCall{runtime.newobject}} [16] v4 v1
v6 (6) = SelectN <mem> [1] v5
v7 (6) = SelectN <*[3]int> [0] v5 (&arr[*[3]int], slice.ptr[*int])
v8 (?) = Addr <*[3]int> {main..stmp_0} v3
v9 (6) = Move <mem> {[3]int} [24] v7 v8 v6
v10 (?) = Const64 <int> [1] (slice.len[int], a.len[int], a.cap[int])
v13 (?) = Const64 <int> [3] (slice.cap[int])
...
v23 (+7) = SliceMake <[]int> v7 v10 v13
...

package main

import "fmt"

func main() {
    oldArr := [5]int{1, 2, 3, 4, 5}
    // 使用下标创建切片
    newSlice := oldArr[0:3]
    fmt.Println("修改切片前-> oldArr:", oldArr, "newSlice:", newSlice)
    // 修改新切片值
    newSlice[0] = 100
    fmt.Println("修改切片后-> oldArr:", oldArr, "newSlice:", newSlice)
}

/** 输出
修改切片前-> oldArr: [1 2 3 4 5] newSlice: [1 2 3]
修改切片后-> oldArr: [100 2 3 4 5] newSlice: [100 2 3]
*/

[]int{1, 2, 3}

var vstat [3]int
vstat[0] = 1
vstat[1] = 2
vstat[2] = 3

var vauto *[3]int = new([3]int)
*vauto = vstat
slice := vauto[:]

    case ir.OMAKE:
        n := n.(*ir.CallExpr)
        return tcMake(n)

    case types.TSLICE:
        // ...
        if ir.IsConst(l, constant.Int) && r != nil && ir.IsConst(r, constant.Int) && constant.Compare(l.Val(), token.GTR, r.Val()) {
            base.Errorf("len larger than cap in make(%v)", t)
            n.SetType(nil)
            return n
        }
        nn = ir.NewMakeExpr(n.Pos(), ir.OMAKESLICE, l, r)

    case ir.OMAKESLICE:
        n := n.(*ir.MakeExpr)
        return walkMakeSlice(n, init)

// walkMakeSlice walks an OMAKESLICE node.
func walkMakeSlice(n *ir.MakeExpr, init *ir.Nodes) ir.Node {
    l := n.Len
    r := n.Cap
    if r == nil {
        r = safeExpr(l, init)
        l = r
    }
    t := n.Type()
    if t.Elem().NotInHeap() {
        base.Errorf("%v can't be allocated in Go; it is incomplete (or unallocatable)", t.Elem())
    }
    if n.Esc() == ir.EscNone {
        if why := escape.HeapAllocReason(n); why != "" {
            base.Fatalf("%v has EscNone, but %v", n, why)
        }
        // var arr [r]T
        // n = arr[:l]
        i := typecheck.IndexConst(r)
        if i < 0 {
            base.Fatalf("walkExpr: invalid index %v", r)
        }

        // cap is constrained to [0,2^31) or [0,2^63) depending on whether
        // we're in 32-bit or 64-bit systems. So it's safe to do:
        //
        // if uint64(len) > cap {
        //     if len < 0 { panicmakeslicelen() }
        //     panicmakeslicecap()
        // }
        nif := ir.NewIfStmt(base.Pos, ir.NewBinaryExpr(base.Pos, ir.OGT, typecheck.Conv(l, types.Types[types.TUINT64]), ir.NewInt(i)), nil, nil)
        niflen := ir.NewIfStmt(base.Pos, ir.NewBinaryExpr(base.Pos, ir.OLT, l, ir.NewInt(0)), nil, nil)
        niflen.Body = []ir.Node{mkcall("panicmakeslicelen", nil, init)}
        nif.Body.Append(niflen, mkcall("panicmakeslicecap", nil, init))
        init.Append(typecheck.Stmt(nif))

        t = types.NewArray(t.Elem(), i) // [r]T
        var_ := typecheck.Temp(t)
        appendWalkStmt(init, ir.NewAssignStmt(base.Pos, var_, nil))  // zero temp
        r := ir.NewSliceExpr(base.Pos, ir.OSLICE, var_, nil, l, nil) // arr[:l]
        // The conv is necessary in case n.Type is named.
        return walkExpr(typecheck.Expr(typecheck.Conv(r, n.Type())), init)
    }

    // n escapes; set up a call to makeslice.
    // When len and cap can fit into int, use makeslice instead of
    // makeslice64, which is faster and shorter on 32 bit platforms.

    len, cap := l, r

    fnname := "makeslice64"
    argtype := types.Types[types.TINT64]

    // Type checking guarantees that TIDEAL len/cap are positive and fit in an int.
    // The case of len or cap overflow when converting TUINT or TUINTPTR to TINT
    // will be handled by the negative range checks in makeslice during runtime.
    if (len.Type().IsKind(types.TIDEAL) || len.Type().Size() <= types.Types[types.TUINT].Size()) &&
        (cap.Type().IsKind(types.TIDEAL) || cap.Type().Size() <= types.Types[types.TUINT].Size()) {
        fnname = "makeslice"
        argtype = types.Types[types.TINT]
    }
    fn := typecheck.LookupRuntime(fnname)
    ptr := mkcall1(fn, types.Types[types.TUNSAFEPTR], init, reflectdata.MakeSliceElemRType(base.Pos, n), typecheck.Conv(len, argtype), typecheck.Conv(cap, argtype))
    ptr.MarkNonNil()
    len = typecheck.Conv(len, types.Types[types.TINT])
    cap = typecheck.Conv(cap, types.Types[types.TINT])
    sh := ir.NewSliceHeaderExpr(base.Pos, t, ptr, len, cap)
    return walkExpr(typecheck.Expr(sh), init)
}

// walkNew walks an ONEW node.
func walkNew(n *ir.UnaryExpr, init *ir.Nodes) ir.Node {
    t := n.Type().Elem()
    if t.NotInHeap() {
        base.Errorf("%v can't be allocated in Go; it is incomplete (or unallocatable)", n.Type().Elem())
    }
    if n.Esc() == ir.EscNone {
        if t.Size() > ir.MaxImplicitStackVarSize {
            base.Fatalf("large ONEW with EscNone: %v", n)
        }
        return stackTempAddr(init, t)
    }
    types.CalcSize(t)
    n.MarkNonNil()
    return n
}

var (
    // MaxStackVarSize is the maximum size variable which we will allocate on the stack.
    // This limit is for explicit variable declarations like "var x T" or "x := ...".
    // Note: the flag smallframes can update this value.
    MaxStackVarSize = int64(10 * 1024 * 1024)

    // MaxImplicitStackVarSize is the maximum size of implicit variables that we will allocate on the stack.
    //   p := new(T)          allocating T on the stack
    //   p := &T{}            allocating T on the stack
    //   s := make([]T, n)    allocating [n]T on the stack
    //   s := []byte("...")   allocating [n]byte on the stack
    // Note: the flag smallframes can update this value.
    MaxImplicitStackVarSize = int64(64 * 1024)

    // MaxSmallArraySize is the maximum size of an array which is considered small.
    // Small arrays will be initialized directly with a sequence of constant stores.
    // Large arrays will be initialized by copying from a static temp.
    // 256 bytes was chosen to minimize generated code + statictmp size.
    MaxSmallArraySize = int64(256)
)

package main

import "fmt"

func main() {
    // --------- 不会扩容 ---------
    // 定义切片a,容量为4
    a := make([]int, 3, 4)
    fmt.Printf("append 前，a -> len:%v cap:%v value:%v \n", len(a), cap(a), a)
    a = append(a, 1)
    fmt.Printf("append 后，a -> len:%v cap:%v value:%v \n", len(a), cap(a), a)

    // --------- 会扩容 ---------
    // 定义切片b，容量为3
    b := make([]int, 3, 3)
    fmt.Printf("append 前，b -> len:%v cap:%v value:%v \n", len(b), cap(b), b)
    b = append(b, 1)
    fmt.Printf("append 后，b -> len:%v cap:%v value:%v \n", len(b), cap(b), b)
}

/** 输出
append 前，a -> len:3 cap:4 value:[0 0 0]
append 后，a -> len:4 cap:4 value:[0 0 0 1]
append 前，b -> len:3 cap:3 value:[0 0 0]
append 后，b -> len:4 cap:6 value:[0 0 0 1]
*/

func growslice(oldPtr unsafe.Pointer, newLen, oldCap, num int, et *_type) slice {
    // ...

    newcap := oldCap
    doublecap := newcap + newcap
    if newLen > doublecap {
        newcap = newLen
    } else {
        const threshold = 256
        if oldCap < threshold {
            newcap = doublecap
        } else {
            // Check 0 < newcap to detect overflow
            // and prevent an infinite loop.
            for 0 < newcap && newcap < newLen {
                // Transition from growing 2x for small slices
                // to growing 1.25x for large slices. This formula
                // gives a smooth-ish transition between the two.
                newcap += (newcap + 3*threshold) / 4
            }
            // Set newcap to the requested cap when
            // the newcap calculation overflowed.
            if newcap <= 0 {
                newcap = newLen
            }
        }
    }

    // ...
}

package main

import "fmt"

func main() {
    /// 定义切片
    oldSli := []int{100, 200, 300}

    // 复制切片
    copySli := oldSli
    fmt.Println("修改前 -> copySli: ", copySli, "oldSli:", oldSli)

    // 修改复制后的切片
    copySli[0] = 99
    fmt.Println("修改后 -> copySli: ", copySli, "oldSli:", oldSli)
}

/** 输出
修改前 -> copySli:  [100 200 300] oldSli: [100 200 300]
修改后 -> copySli:  [99 200 300] oldSli: [99 200 300]
*/

package main

import "fmt"

func main() {
    // 定义切片
    oldSli := []int{100, 200, 300}

    // 使用 copy 复制切片
    copySli := make([]int, len(oldSli), cap(oldSli))
    copy(copySli, oldSli)
    fmt.Println("修改前 -> copySli: ", copySli, "oldSli:", oldSli)

    // 修改复制后的切片
    copySli[0] = 99
    fmt.Println("修改后 -> copySli: ", copySli, "oldSli:", oldSli)
}

/** 输出
修改前 -> copySli:  [100 200 300] oldSli: [100 200 300]
修改后 -> copySli:  [99 200 300] oldSli: [100 200 300]
*/