第 10 节：复合类型-5. 指针 -- 数组指针与指针数组

3. 数组指针

前面在讲解数组的时候，我们用数组作为函数参数，但是数组作为参数进行传递是值传递，如果想引用传递，可以使用数组指针。具体使用方式如下：

\
定义一个数组，作为函数 Swap 的实参进行传递，但是这里传递的是数组的地址，所以 Swap 的形参是数组指针。，\
这时指针 p，指向了数组 a, 对指针 p 的操作实际上是对数组 a 的操作，所以如果直接执行如下语句：fmt.Println (p), 会输出数组 a 中的值。也可以通过 p 结合下标将对应的值取出来进行修改。最终在 main 函数中输出数组 a，发现其元素也已经修改。\
当然，我们也可以通过循环的方式来将数组指针中的数据打印出来：

package main

import "fmt"

func main0501() {

    arr := [10]int{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}

    //定义指针 指向数组  数组指针
    //自动推导类型创建数组指针
    //p := &arr

    //指针和数组建立关系
    var p *[10]int
    p = &arr

    //fmt.Printf("%T\n", p)

    //通过指针间接操作数组

    //fmt.Println(len(p))
    for i := 0; i < len(p); i++ {
        fmt.Println(p[i])
    }
    //(*数组指针变量)[下标]=值
    //(*p)[1] = 222
    //数组指针可以直接操作数组元素
    //p[1] = 222//ok
    //fmt.Println(*p)
}

func main0502() {
    arr := [5]int{1, 2, 3, 4, 5}
    //指针变量和要存储的数据类型要相同

    //p1和p2在内存中指向相同的地址  但是p1和p2的类型不同 一个是指向整个数组   一个是指向数组的元素
    p1 := &arr
    //p2 := &arr[0]

    //fmt.Printf("%p\n", p1)
    //fmt.Printf("%p\n", p2)
    //
    //fmt.Printf("%T\n", p1)
    //fmt.Printf("%T\n", p2)

    for i := 0; i < len(p1); i++ {
        fmt.Println(p1[i])
    }

}

//将数组指针作为函数参数

//func test2(p *[5]int) {
//
//  //通过指针间接操作数组
//  p[2] = 123
//
//}
//将数组指针作为函数参数
func BubbleSort(arr *[10]int) {

    for i := 0; i < len(arr)-1; i++ {
        for j := 0; j < len(arr)-1-i; j++ {
            if arr[j] > arr[j+1] {
                arr[j], arr[j+1] = arr[j+1], arr[j]
            }
        }
    }
}
func main() {
    arr := [10]int{9, 1, 5, 6, 8, 4, 10, 7, 2, 3}
    //p := &arr
    //地址传递
    //test2(p)

    BubbleSort(&arr)
    fmt.Println(arr)
}

4. 指针数组 -- 不容易懂重点

上一小节，讲解到的是数组指针，也就是让一个指针指向数组 ，然后可以通过该指针来操作数组。还有一个概念叫指针数组，这两个概念很容混淆，指针数组指的是一个数组中存储的都是指针（也就是地址）。也就是一个存储了地址的数组。\
下面通过一个案例，看一下指针数组的应用\

package main

import "fmt"

func main0601() {

    //var arr [10]int
    //指针数组  数组元素是指针类型
    a := 10
    b := 20
    c := 30
    var arr [3]*int = [3]*int{&a, &b, &c}

    //fmt.Println(arr)
    //
    //fmt.Println(&a)
    //fmt.Println(&b)
    //fmt.Println(&c)

    //*arr[1] = 200

    //fmt.Println(b)

    for i := 0; i < len(arr); i++ {
        fmt.Println(*arr[i])
    }
}
func main() {
    a := [3]int{1, 2, 3}
    b := [3]int{4, 5, 6}
    c := [3]int{7, 8, 9}

    //p := &a

    //二维数组模型
    var arr [3]*[3]int = [3]*[3]int{&a, &b, &c}

    fmt.Println(arr)
    //fmt.Printf("%T\n", p)

    //for i := 0; i < len(arr); i++ {
    //  //fmt.Println(*arr[i])//[3]int类型
    //  for j := 0; j < len(*arr[i]); j++ {
    //      fmt.Printf("%d ", (*arr[i])[j])
    //  }
    //  fmt.Println()
    //}

    (*arr[1])[1] = 555

    fmt.Println(b)
}

本作品采用《CC 协议》，转载必须注明作者和本文链接