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

码农世界 2024-06-04 后端 132 次浏览 0个评论

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

五、数组、切片和指针

1. 数组

1.1 声明和初始化数组
1.2 访问和修改数组元素
1.3 多维数组
2. 切片

2.1 声明和初始化切片
2.2 访问和修改切片元素
2.3 切片操作
2.4 切片的追加和拷贝
3. 指针

3.1 声明和初始化指针
3.2 指针与函数

3.3 指针数组和数组指针

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
}