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

目录

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

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

---

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

---

五、数组、切片和指针

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

1. 数组

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

1.1 声明和初始化数组

package main

import "fmt"

func main() {
    // 声明一个长度为 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"

func main() {
    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"

func main() {
    // 声明一个 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"

func main() {
    // 声明一个长度为 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"

func main() {
    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"

func main() {
    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"

func main() {
    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"

func main() {
    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 的指针
func updateValue(p *int) {
    *p = 200
}

func main() {
    a := 100
    fmt.Println("Before:", a) // 输出：100

    // 将 a 的地址传递给函数
    updateValue(&a)

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

3.3 指针数组和数组指针

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

package main

import "fmt"

func main() {
    // 指针数组
    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)

---