[golang]array与slice

最新推荐文章于 2022-04-12 20:21:31 发布

moxiaomomo

最新推荐文章于 2022-04-12 20:21:31 发布

阅读量695

点赞数 1

分类专栏： Golang 文章标签： golang

本文链接：https://blog.csdn.net/moxiaomomo/article/details/76824378

版权

Golang 专栏收录该内容

32 篇文章 2 订阅

订阅专栏

array类型

1)基础特性

array为固定长度的数组, 其内存分配为连续的, 使用前需确定长度;
数组为值类型, 赋值操作的新变量是原数组的一份完整拷贝;
作为函数的传递参数, 实际也是数组的一份拷贝, 效率也就比传递指针低;
数组长度也是Type一部分, 如[4]int和[2]int类型不一样.

2)声明与初始化

package main
import "fmt"

// 只声明, 不作初始化
var a1 [3]int         //一维, [0 0 0]
var a2 [2][2]int      //二维, [[0,0],[0,0]]

// 声明并初始化
var b1 [5]int = [5]int{1,2,3,4,5}
var b2 [4]string = [4]string{"Red", "Blue", "Green", "Yellow"}
var b3 [2][2]int = [2][2]int{[2]int{5,6}, [2]int{7,8}}
// 不能在顶层进行快速声明和初始化, 需用: var b4 [3]string = ...
//b4 := [3]string{"a", "b", "c"}

// 几种常用初始化方法(在函数内使用)
func arrInFunc(){
    a := [3]int{1,2,3}    // 所有元素赋值
    b := [5]int{1,2,3}    // 前三个元素赋值，其他默认0
    c := [15]int{10:3}    // 指定第11个元素初始化为3，其他默认0
    d := [...]int{4,5,6}  // 编译器自动推断长度
    e := [...]int{0:1, 1:2, 5:7} //自动推断长度
    fmt.Printf("%v\n", a)
    fmt.Printf("%v\n", b)
    fmt.Printf("%v\n", c)
    fmt.Printf("%v\n", d)
    fmt.Printf("%v\n", e)
}

func main(){
    arrInFunc()
}

main.go演示效果如下:

root@XIAOMO:~/gopro# ./main
[1 2 3]
[1 2 3 0 0]
[0 0 0 0 0 0 0 0 0 0 3 0 0 0 0]
[4 5 6]
[1 2 0 0 0 7]

3)元素访问

main.go示例

package main

func accessElem() {
    array := [3]int{1, 3, 9}

    // 通过下标访问
    for i:=0; i < len(array); i++ {
        fmt.Println(i, array[i])
    }

    // 迭代方式访问
    for i, v := range array {
        fmt.Println(i, v)
    }

    // 使用new创建数组,零值填充, 返回数组指针
    p := new([5]int)
    fmt.Println(*p)
}

func main(){
    accessElem()
}

示例演示效果:

root@XIAOMO:~/gopro# ./main
0 1
1 3
2 9
0 1
1 3
2 9
[0 0 0 0 0]

4)在函数中传递数组

和C++类似, 函数参数传递中可以传值或传指针:

// 传值, 每次调用foo1, 系统将分配16字节内存在栈上
// 函数运行结束时, 会弹栈并释放16字节内存
func foo1(arr [16]int) {
   // ...
}
var a [16]int
foo1(a)

// 传指针, 每次调用foo2, 系统将只分配指针需要的内存空间
func foo2(arr *[16]int){
    // ...
}
var b [16]int
foo2(&b)

slice类型

1)基础特性

slice是一种动态数组, 可以认为是指向数组的指针; 但其并不只是指针，本身有其数据结构, 该结构包含三个元素:
- 指向原生数组的指针(pointer)
- 数组切片的元素个数(len)
- 数组切片已分配的空间(cap)
slice作为一个引用类型, 声明是不需要指定长度;
增长操作通过内建方法append实现, 内部实现自动扩容.

2)创建和初始化

main.go

package main

func createSlice() {
    // 通过array创建slice, 用法神似python
    arr := [5]int{1,2,3,4,5}
    sli1 := arr[:3]  // 切出前三个元素
    sli2 := arr[:4]  // 切出前四个元素
    sli1[1] = 8
    sli2[1] = 9
    // 将打印 9 9 9, 可见修改的是同一个元素
    println(arr[1], sli1[1], sli2[1])

    // 通过make创建slice
    sli3 := make([]int, 3)
    sli4 := make([]int, 4, 8) //初始4个元素，预留8个元素的空间
    sli5 := []int{1,2,3,4,5}  //初始化赋值
    fmt.Printf("%v\n", sli3)
    fmt.Printf("%v\n", sli4)
    fmt.Printf("%v\n", sli5)
}

func main(){
    createSlice()
}

3)元素访问

package main

func useSlice() {
    slice := []int{10, 20, 30, 40, 50}
    for index, value := range slice {
        fmt.Printf("Index: %d  Value: %d\n", index, value)
    }

    for i := 0; i < len(slice); i++ {
        fmt.Printf("Index: %d  Value: %d\n", i, slice[i])
    }
}

func main(){
    useSlice()
}