golang slice 深入理解

golang slice 类似定义

// runtime/slice.go
type slice struct {
	array unsafe.Pointer // point to raw array 
	len   int // count of items
	cap   int // capcity of slice 
}

package main

import "fmt"

func foo(s []int) {
    fmt.Printf("&foo:s: %p\n", &s) // 0xc00000c080
    fmt.Printf("&foo:s[0]: %p\n", &s[0]) // 0xc00001a300

    for i := 0; i < len(s); i++ {
        s[i]++
    }
}
func main() {
    s := []int{1, 2, 3, 4, 5}
    fmt.Printf("&main:s: %p\n", s) // 0xc00001a300	
    fmt.Printf("&main:s[0]: %p\n", &s[0]) // 0xc00001a300
    foo(s)
    fmt.Println(s) // [2 3 4 5 6]
}

转为C语言的例子

#include <stdio.h>

int foo(int *p, int len)
{
    printf("&foo:p: %p\n", &p); // 0x7ffc16e33d18
    printf("&foo:p[0]: %p\n", &p[0]); // 0x7ffc16e33d50    即 &(*(p + 0)) 
    for(int i = 0; i < len; i++)
    {
        p[i] += 1; //即 *(p + i) += 1;
    }
}

int main()
{
    int  a[] =  {1, 2, 3, 4, 5};
    int *p = &a;
    printf("&main:p: %p\n", &p); // 0x7ffc16e33d48
    printf("&main:a[0]: %p\n", &a[0]); // 0x7ffc16e33d50
    
    int len = sizeof(a) / sizeof(a[0]);
    foo(p, len);

    for(int i = 0; i < len; i++) 
    {
        printf("%d\n", p[i]); //打印 2 3 4 5 6
    }

    return 0;
}

结合上面的例子

问题一

为什么 &main:s 和 &foo:s不一样?
答: 因为 foo函数中的s是一个独立的slice类型变量 , 对照C语言的例子很容易理解

问题二
为什么 &main:s[0] 和 &foo:s[0] 是一样的?
答: 因为都是指向同一片地址空间. 对照C 语言例子即可理解. Golang自身完成了很多"自动"对指针的解引用(*)操作 和 取地址操作(&), 而不需要开发人员手写 (*) 和 (&)

问题三
从以上例子来看, 是不是可以下结论: slice作为函数参数传递时都是"指针传递", 可以在(被调用)函数中通过slice修改原slice?
答: slice作为函数参数时是"值传递"(即C语言中的"指针传递") , 即slice类型中的 array unsafe.Pointer 字段和原slice(即实参)是指向相同的 “原始数组”. 所以可以修改"原始数组".
但是, 需要注意的是, slice是可以改变"指向"的, 类似C中指针改变"指向"一样.

package main

import "fmt"

func foo(s []int) {
	fmt.Printf("&foo:s: %p\n", &s)       // 0xc00000c080
	fmt.Printf("&foo:s[0]: %p\n", &s[0]) // 0xc00001a300

	for i := 0; i < len(s); i++ {
		s[i]++
	}

	// 以下append函数中, s的容量已不够, 所以append函数中新建了一个数组, s的指向也改变了
	fmt.Printf("==========\n")
	s = append(s, 99)  
	fmt.Printf("&foo:s[0]: %p\n", &s[0]) // 0xc00001c0f0
	s = append(s, 999)
	fmt.Printf("&foo:s[0]: %p\n", &s[0]) // 0xc00001c0f0

}
func main() {
	s := []int{1, 2, 3, 4, 5}
	fmt.Printf("&main:s: %p\n", s)        // 0xc00001a300
	fmt.Printf("&main:s[0]: %p\n", &s[0]) // 0xc00001a300
	foo(s)
	fmt.Println(s) // [2 3 4 5 6]
}