One, type
An array is a value type, and when an array is assigned to another array, a copy is passed.
A slice is a reference type, and an array of sliced wrappers is called the underlying array of that slice.
Let's look at a piece of code
A is an array, note that the array is a fixed length, the initialization must be specified length, not specified length is sliced a
: = [3]int{1, 2, 3}
//b is an array, is a copy of
B: = a
//c is a slice, is a reference type, the underlying array is a
c: = a[:] for
I: = 0; i < Len (a); i++ {
a[i] = a[i] + 1
}
//Change A's value, B is a copy, B is unchanged, C is reference, C's Value changes
FMT. Println (a)//[2,3,4]
FMT. Println (b)//[1 2 3]
FMT. Println (c)//[2,3,4]
Two, make
Make can only be used slice
, map
and channel
, so the following section of code generates a slice
reference type
S1: = Make ([]int, 0, 3) for
I: = 0; I < caps (S1); i++ {
S1 = append (S1, i)
}
s2: = S1 for
i: = 0; I < Len (a); i++ {
S1[i] = s1[i] + 1
}
fmt. Println (S1)//[1 2 3]
FMT. PRINTLN (S2)//[1 2 3]
Third, when the slice append exceeds the bounds of the underlying array
N1 is the underlying array of n2
n1: = [3]int{1, 2, 3}
n2: = N1[0:3]
fmt. PRINTLN ("Address of items in N1:") for
I: = 0; I < Len (N1); i++ {
FMT. Printf ("%p\n", &n1[i])
}
//address of items in N1:
//0xc20801e160
//0xc20801e168
// 0xc20801e170
FMT. PRINTLN ("Address of items in N2:") for
I: = 0; I < Len (N2); i++ {
FMT. Printf ("%p\n", &n2[i])
}
//address of items in N2:
//0xc20801e160
//0xc20801e168
// After the 0xc20801e170
//n2 append operation, N2 exceeded the N1 of J
n2 = Append (n2, 1) of the underlying array
. PRINTLN ("Address of items in N1:") for
I: = 0; I < Len (N1); i++ {
FMT. Printf ("%p\n", &n1[i])
}
//address of items in N1:
//0xc20801e160
//0xc20801e168
// 0xc20801e170
FMT. PRINTLN ("Address of items in N2:") for
I: = 0; I < Len (N2); i++ {
FMT. Printf ("%p\n", &n2[i])
}
//address of items in N2:
//0xc20803a2d0
//0xc20803a2d8
// 0XC20803A2E0
//0xc20803a2e8
Iv. reference to "failure"
Implements the deletion slice
item
of the last function
Func Rmlast (A []int) {
fmt. Printf ("[Rmlast]" The address of A is%p ", a)
a = A[:len (a)-1]
FMT. Printf ("[Rmlast] after remove, the address of A is%p", a)
}
After calling this function, we found that the original slice
did not change
Func Main () {
xyz: = []int{1, 2, 3, 4, 5, 6, 7, 8, 9}
FMT. PRINTF ("[main] the" the address of XYZ is%p\n ", xyz)
Rmlast (XYZ)
FMT. PRINTF ("[main] after remove, the address of XYZ is%p\n", xyz)
FMT. Printf ("%v", xyz)//[1 2 3 4 5 6 7 8 9]
}
The results printed are as follows:
[Main] The "address" of XYZ
is 0xc2080365f0 [rmlast] The address of a
is 0xc2080365f0 [rmlast] After remove, the A Ddress of A is 0xc2080365f0
[main] After remove, the address of XYZ is 0xc2080365f0
[1 2 3 4 5 6 7 8 9]
Here the direct print slice
of the pointer value, because slice
it is a reference type, so the pointer values are the same, we change slice
the printed address to see
Func Rmlast (A []int) {
fmt. Printf ("[Rmlast]" The address of A is%p ", &a)
a = A[:len (a)-1]
FMT. Printf ("[Rmlast] after remove, the address of A is%p", &a)
}
func main () {
xyz: = []int{1, 2, 3, 4, 5, 6, 7, 8, 9}
FMT. PRINTF ([main] The address of XYZ is%p\n, &xyz)
rmlast (XYZ)
FMT. PRINTF ("[main] after remove, the address of XYZ is%p\n", &xyz)
FMT. Printf ("%v", xyz)//[1 2 3 4 5 6 7 8 9]
}
Results:
[Main] The "address" of XYZ
is 0xc20801e1e0 [rmlast] The address of a
is 0xc20801e200 [rmlast] After remove, the A Ddress of A is 0xc20801e200
[main] After remove, the address of XYZ is 0xc20801e1e0
[1 2 3 4 5 6 7 8 9]
This time, you can see that when you pass the function slice
as a function argument, you actually copy it too, slice
because slice
it's a pointer, so from the point of view, slice
It's a reference type.
Summarize
The above is the entire content of this article, I hope that the study or work to bring some help, if you have questions you can message exchange.