9.6 Go语言入门(数组、切片和指针)

Go语言入门（数组、切片和指针）

目录

Go 语言（Golang）是一种静态类型、编译型语言，由 Google 开发，专注于简洁性、并发和高效性。

下面是 Go 语言的基础语法讲解和代码示例。

上一篇：四、Go语言入门（条件语句和循环语句）

五、数组、切片和指针

在 Go 语言中，数组、切片和指针是非常重要的数据结构和概念。它们各自有不同的用途和特性，理解它们有助于编写高效和清晰的代码。下面详细讲解 Go 语言中的数组、切片和指针，并提供代码示例。

1. 数组

数组是固定长度的同类型元素的集合。数组的长度在声明时就确定了，之后不能改变。

1.1 声明和初始化数组

package main

import"fmt"funcmain(){// 声明一个长度为 5 的整型数组，并初始化var arr1 [5]int
    fmt.Println(arr1)// 输出：[0 0 0 0 0]// 使用字面量初始化数组
    arr2 :=[5]int{1,2,3,4,5}
    fmt.Println(arr2)// 输出：[1 2 3 4 5]// 部分初始化，未指定的元素使用默认值
    arr3 :=[5]int{1,2}
    fmt.Println(arr3)// 输出：[1 2 0 0 0]// 使用 ... 推断数组长度
    arr4 :=[...]int{1,2,3}
    fmt.Println(arr4)// 输出：[1 2 3]}

1.2 访问和修改数组元素

package main

import"fmt"funcmain(){
    arr :=[5]int{1,2,3,4,5}// 访问数组元素
    fmt.Println(arr[0])// 输出：1// 修改数组元素
    arr[0]=10
    fmt.Println(arr)// 输出：[10 2 3 4 5]}

1.3 多维数组

package main

import"fmt"funcmain(){// 声明一个 2x3 的二维数组var matrix [2][3]int
    fmt.Println(matrix)// 输出：[[0 0 0] [0 0 0]]// 初始化二维数组
    matrix =[2][3]int{{1,2,3},{4,5,6}}
    fmt.Println(matrix)// 输出：[[1 2 3] [4 5 6]]}

2. 切片

切片是一个动态数组，可以根据需要自动扩展。切片比数组更灵活，更常用。

2.1 声明和初始化切片

package main

import"fmt"funcmain(){// 声明一个长度为 3 的整型切片，并初始化var s1 []int
    fmt.Println(s1)// 输出：[]// 使用字面量初始化切片
    s2 :=[]int{1,2,3,4,5}
    fmt.Println(s2)// 输出：[1 2 3 4 5]// 使用 make 函数创建切片
    s3 :=make([]int,5)// 创建长度为 5 的切片，元素初始值为 0
    fmt.Println(s3)// 输出：[0 0 0 0 0]// 创建一个长度为 3，容量为 5 的切片
    s4 :=make([]int,3,5)
    fmt.Println(s4)// 输出：[0 0 0]}

2.2 访问和修改切片元素

package main

import"fmt"funcmain(){
    s :=[]int{1,2,3,4,5}// 访问切片元素
    fmt.Println(s[0])// 输出：1// 修改切片元素
    s[0]=10
    fmt.Println(s)// 输出：[10 2 3 4 5]}

2.3 切片操作

切片支持切片操作符，允许从现有切片中创建新的切片。

package main

import"fmt"funcmain(){
    s :=[]int{1,2,3,4,5}// 从索引 1 到索引 3 创建一个新的切片（不包括索引 3）
    s1 := s[1:3]
    fmt.Println(s1)// 输出：[2 3]// 省略开始索引表示从头开始
    s2 := s[:3]
    fmt.Println(s2)// 输出：[1 2 3]// 省略结束索引表示直到最后
    s3 := s[2:]
    fmt.Println(s3)// 输出：[3 4 5]// 完全省略表示整个切片
    s4 := s[:]
    fmt.Println(s4)// 输出：[1 2 3 4 5]}

2.4 切片的追加和拷贝

使用 append 函数可以向切片中追加元素，使用 copy 函数可以拷贝切片。

package main

import"fmt"funcmain(){
    s :=[]int{1,2,3}// 追加单个元素
    s =append(s,4)
    fmt.Println(s)// 输出：[1 2 3 4]// 追加多个元素
    s =append(s,5,6,7)
    fmt.Println(s)// 输出：[1 2 3 4 5 6 7]// 追加一个切片
    s2 :=[]int{8,9}
    s =append(s, s2...)
    fmt.Println(s)// 输出：[1 2 3 4 5 6 7 8 9]// 拷贝切片
    s3 :=make([]int,len(s))copy(s3, s)
    fmt.Println(s3)// 输出：[1 2 3 4 5 6 7 8 9]}

3. 指针

指针是存储另一个变量的内存地址的变量。在 Go 中，指针可以用来传递大对象以避免拷贝，提高性能。

3.1 声明和初始化指针

package main

import"fmt"funcmain(){var a int=10// 声明一个指向 int 的指针var p *int// 将 a 的地址赋值给 p
    p =&a

    // 访问指针变量的值
    fmt.Println("Address of a:", p)// 输出：a 的地址
    fmt.Println("Value of *p:",*p)// 输出：10// 修改指针指向的值*p =20
    fmt.Println("New value of a:", a)// 输出：20}

3.2 指针与函数

指针可以作为函数参数，用于传递大对象以避免拷贝。

package main

import"fmt"// 函数参数是一个指向 int 的指针funcupdateValue(p *int){*p =200}funcmain(){
    a :=100
    fmt.Println("Before:", a)// 输出：100// 将 a 的地址传递给函数updateValue(&a)

    fmt.Println("After:", a)// 输出：200}

3.3 指针数组和数组指针

指针数组是包含指针的数组，数组指针是指向数组的指针。

package main

import"fmt"funcmain(){// 指针数组
    arr1 :=[3]*int{}
    a, b, c :=1,2,3
    arr1[0]=&a
    arr1[1]=&b
    arr1[2]=&c

    for i, p :=range arr1 {
        fmt.Println(i,*p)// 输出：0 1, 1 2, 2 3}// 数组指针
    arr2 :=[3]int{1,2,3}var p *[3]int=&arr2

    fmt.Println(p)// 输出：&[1 2 3]
    fmt.Println(*p)// 输出：[1 2 3]
    fmt.Println((*p)[1])// 输出：2}

通过理解数组、切片和指针，能够更好地处理复杂的数据结构和内存管理，提高程序的效率和性能。

下一篇：六、Go语言入门(映射 Map)