由引用类型引发的概念的深入理解-go深入-利志分享

由引用类型引发的概念的深入理解

阅读：51 分享次数：0

我们从百度百科上面看引用的概念：引用类型 由类型的实际值引用（类似于指针）表示的数据类型。如果为某个变量分配一个引用类型，则该变量将引用（或“指向”）原始值。

这里是什么意思呢，意思是假如一个a变量是数组，这个数组的类型是引用类型，a有a[0]='111'，'111'保存在另外一个数据结构b里面，这里的a[0]是指向的这个b数据的地址。

下面我们来通过例子理解一下。
    package main
    
    import (
      "fmt"
    )
    
    func main() {
      //这里是初始化声明赋值一个a
      //a := []int{3, 4, 5}
      a := make([]int, 3)
      a[0] = 3
      a[1] = 4
      a[2] = 5
      test(a)
      fmt.Println(a)
      test2(a)
      fmt.Println(a)
      b := map[string]string{
        "a": "b",
      }
      test3(b)
      fmt.Println(b)
      test4(b)
      fmt.Println(b)
    }
    
    func test(a []int) {
      a[2] = 6
    }
    
    func test2(a []int) {
      //a = append(a, 9)
      a = []int{8, 93, 3, 11}
      fmt.Println("test2 a", a)
    }
    
    func test3(b map[string]string) {
      b["xx"] = "xxxx"
    }
    
    func test4(b map[string]string) {
      b = map[string]string{
        "888": "999",
      }
    }
下面我们看下结果：

------------
第一次：[3 4 6]   这里是直接修改a的值，修改第二个值，打印是返回的值
test2 a [8 93 3 11]    这里是在test2函数里面修改a的值，打印出来的
第二次：[3 4 6]    这里是test2函数执行之后返回的结果，a本身没有变化，这里可以看出a本身不是引用的，但是a里面的值的变量是有引用的
第一次：map[a:b xx:xxxx] 这里是map类型b的样例，第一次是修改或者追加key和value，打印返回的值是修改成功的
第二次：map[a:b xx:xxxx]   这里是第二次去本身函数改变，返回的b本身是不修改的，这里也同样证明b本身不是引用的，b的值是有引用的
好了，那么来了，如何对引用类型修改本身，那其实很简单就是让他们传地址到函数中，在函数中修改，函数执行完了，变量在函数中变化之后会在函数外也体现出来

------------
下面我们看一下a slice的底层实现结构体如下，如果我们直接使用它，它只有属性array是指向一个地址的

type slice struct {
      array unsafe.Pointer
      len   int
      cap   int
    }
顺便我们了解下b map的底层实现结构体是什么，其实我们存的值是在buckets里面，也是一个指针。

type hmap struct {
      // Note: the format of the hmap is also encoded in cmd/compile/internal/gc/reflect.go.
      // Make sure this stays in sync with the compiler's definition.
      count     int // # live cells == size of map.  Must be first (used by len() builtin)
      flags     uint8
      B         uint8  // log_2 of # of buckets (can hold up to loadFactor * 2^B items)
      noverflow uint16 // approximate number of overflow buckets; see incrnoverflow for details
      hash0     uint32 // hash seed
    
      buckets    unsafe.Pointer // array of 2^B Buckets. may be nil if count==0.
      oldbuckets unsafe.Pointer // previous bucket array of half the size, non-nil only when growing
      nevacuate  uintptr        // progress counter for evacuation (buckets less than this have been evacuated)
    
      extra *mapextra // optional fields
    }

为了确定这个引用类型的知识点，我特意去用java写了个例子，看看是不是语言通用的，java的本身底层函数实现我就没有去了解了，后续有时间去尝试。

import org.junit.Test;
    
    public class Application {
        @Test
        public void main() {
            String[] str = {"xxx", "bbb"};
            System.out.println("初始化数据："+str[1]);
            test(str);
            System.out.println("第一次："+str[1]);
            test2(str);
            System.out.println("第二次："+str[1]);
        }
    
        public void test(String[] str) {
            str[1] = "2";
        }
    
        public void test2(String[] str) {
            str = new String[]{"5", "6"};
        }
    }

下面是java的返回的结果

------------

初始化数据：bbb 初始化是bbb
第一次：2   修改函数里面的值，返回的是修改的值
第二次：2   这里是本str本身进行修改，修改完了之后，函数外之后执行没有变化。

------------
好了，到这里我们对引用类型有了深入的理解了，后面有对底层slice和map的实现进行进一步了解和学习。

感觉本站内容不错，读后有收获？

我要小额打赏，鼓励作者写出更好的教程

扫码关注公众号：talk_lizhi