• go语言数组、切片和指针


    go语言教程:安装入门➡️for循环

    高维数组

    前面已经讲到过基本的数组声明方式

    var a [3]int	// a是长度为3的数组,内容为0
    var b = [3]int{1, 2, 3}
    c := [3]int{1,2,3}
    
    • 1
    • 2
    • 3

    由于数组只需要内部元素有着相同类型,所以自然地衍生出一个问题:数组是否可以作为另一个数组的元素?此即二维数组。下面列举几个二维数组初始化的案例

    a := [3][2]int{  
     {0, 1},
     {2, 3},
     {4, 5}, 
    }
    
    b := [3][2]int{  
     {0, 1},
     {2, 3},
     {4, 5}}
    
    c := [3][2]int{{0, 1},  {2, 3},  {4, 5}}
    
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12

    b和a完全相同,只是最后一行少了个逗号,所以必须把最后一个花括号挪上去。

    下面做一个测试

    // arr.go
    package main
    import "fmt"
    
    func arrTest1(){
    	c := [3][2]int{{0, 1},  {2, 3},  {4, 5}}
    	for i,r := range c{
    		for j,x := range r{
    			fmt.Println("c[",i,"][",j,"]=",x)
    		}
    	}
    }
    
    func main(){
    	arrTest1()
    }
    
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16

    结果如下

    >go run arr.go
    c[ 0 ][ 0 ]= 0
    c[ 0 ][ 1 ]= 1
    c[ 1 ][ 0 ]= 2
    c[ 1 ][ 1 ]= 3
    c[ 2 ][ 0 ]= 4
    c[ 2 ][ 1 ]= 5
    
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7

    理论上数组的维度是可以不断递增的,比如下面的代码可以初始化一段 2 × 3 × 4 2\times3\times4 2×3×4的数组

    var triArr1 [2][3][4] int
    triArr2 := [2][3][4] int
    
    • 1
    • 2

    切片

    在go语言中,数组元素是固定的,因此实际使用时会受到许多限制。相比之下,切片更加强大而易用。

    就写法来说,只要声明一个未定义长度的数组,即表示新建并初始化了一个切片。据说在生成并初始化一个切片的同时,也会默认生成一个长度固定的数组。而且这个数组还会影响切片的长度。通过关键字make可以声明一个定义了最大长度的切片。

    func slTest()  {
    	sl1 := []int{1,2,3,4,5}
    	fmt.Println("sl1=",sl1)
    	fmt.Println("sl1[1:4]=",sl1[1:4])	//slice索引
    	fmt.Println("sl1[1:4]=",sl1[:4])	//左端默认为0,右端默认为切片长度
    	var sl2 = make([]int,3,5)
    	fmt.Printf("len=%d cap=%d slice=%v\n", len(sl2),cap(sl2),sl2)
    }
    
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8

    其中,len()返回切片长度;cap()返回切片的最大长度,运行结果如下

    >go run arr.go
    sl1= [1 2 3 4 5]
    sl1[1:4]= [2 3 4]
    sl1[1:4]= [1 2 3 4]
    len=3 cap=5 slice=[0 0 0]
    
    • 1
    • 2
    • 3
    • 4
    • 5

    指针

    支持数组这个并不稀奇,但凡有一点野心的编程语言,都会支持数组。但指针就太让人意外了,这种几乎只在C语言中出现的古老工具,竟然出现再了如此年轻的go语言身上,可能ken就好这口吧。

    和C语言类似,定义指针需用到*,指向某个内存地址,其取地址符为&,示例如下

    func ptrTest(){
    	var arr [5]int			//声明一个长度为5的数组
    	for i := 0; i<5; i++{
    		arr[i] = i*i
    		fmt.Printf("第 %d 位赋值为 %d \n",i,arr[i])
    	}
    
    	var ip *int
    	var fp *float64
    	ip = &arr[0]	//将ip指向arr[0]的地址
    	fmt.Printf("fp的值为:%x\n",fp)	//由于fp未赋值,所以为空指针
    	fmt.Printf("ip的值为:%x\n",ip)
    }
    
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13

    其中,ip是一个整型指针,fp是一个浮点型指针,

    运行结果如下

    >go run arr.go0 位赋值为 01 位赋值为 12 位赋值为 43 位赋值为 94 位赋值为 16
    fp的值为:0
    ip的值为:c000012480
    
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
  • 相关阅读:
    【yolov5】pytorch模型导出为onnx模型
    C++中的自定义数据类型(结构体)解析
    安卓WebApp开发-项目MiliSetu
    开关电源-交流220V降压电路-电阻电容降压原理
    写给小白的开源编译器
    Conda常用命令和操作
    golang常用库之-操作redis go-redis/redis库、 go-redsync/redsync库(redis分布式锁)
    C++11 右值引用核心
    containerd 源码分析:kubelet 和 containerd 交互
    17 HAP 覆盖特性与链路损耗特性分析
  • 原文地址:https://blog.csdn.net/m0_37816922/article/details/133364847