GO语言入门5---数组、指针、结构体和切片

目录

---

数组

数组的定义

package main // 固定
import "fmt"

const arrLength=5

func ShowArr(arr [arrLength]int) {
    for i,x := range arr {
        fmt.Println(i, x)
    }
}

func main() { // 大括号的位置是固定的
    // 定义数组的第一种方式
    var a[arrLength] int;
    for index := 0; index < arrLength; index++{
        a[index]=index;
    }
    ShowArr(a)

    // 定义数组的第二种方式
    var b = [...]int{0,1,2,3,4}
    ShowArr(b)
}

二维数组

package main // 固定
import "fmt"

func main() { // 大括号的位置是固定的
    // 定义二维数组
    var array[2][2] int;
    array[0][0] = 0
    array[0][1] = 1
    array[1][0] = 2
    array[1][1] = 3
    for index_i := 0; index_i < 2;  index_i++{
        for index_j := 0; index_j < 2;  index_j++{
            fmt.Println(array[index_i][index_j])
        }
    }
}

多维数组

package main // 固定
import "fmt"

func main() { // 大括号的位置是固定的
    // 定义二维数组
    var array[2][2][2] int;
    array[0][0][0] = 0
    array[0][0][1] = 1
    array[0][1][0] = 2
    array[0][1][1] = 3
    array[1][0][0] = 4
    array[1][0][1] = 5
    array[1][1][0] = 6
    array[1][1][1] = 7
    for index_i := 0; index_i < 2;  index_i++{
        for index_j := 0; index_j < 2;  index_j++{
            for index_k := 0; index_k < 2; index_k++ {
                fmt.Println(array[index_i][index_j][index_k])
            }
        }
    }
}

数组作为函数的参数

package main // 固定
import "fmt"

func ShowArr(arr []int) {
    for i,x := range arr {
        fmt.Println(i, x)
    }
}

func main() { // 大括号的位置是固定的
    var array = []int{1, 2, 3, 4}
    ShowArr(array)

    var array2 [4]int
    for index := 0; index < 4; index++{
        a[index]=index;
    }
    ShowArr(array2) // 这里会报错
}

---

指针

指针的简单实用

package main // 固定
import "fmt"

func main() { // 大括号的位置是固定的
    var p *int
    age:=21
    p = &age
    fmt.Println(*p) // 打印指针的值
    fmt.Println(p) // 打印指针的地址

    var pNil *int
    fmt.Println(pNil) // 打印空指针
}

指针数组

package main // 固定
import "fmt"

func main() { // 大括号的位置是固定的
    var prtArr [3]*int
    a:=10
    b:=11
    c:=12
    prtArr[0]=&a
    prtArr[1]=&b
    prtArr[2]=&c
    fmt.Println(prtArr[0], prtArr[1], prtArr[2])
    fmt.Println(*prtArr[0], *prtArr[1], *prtArr[2])
}

指向指针的指针

package main // 固定
import "fmt"

func main() { // 大括号的位置是固定的
    a:=10
    var p *int
    p = &a
    fmt.Println(*p)

    var pp **int // 二级指针
    pp = &p
    fmt.Println(**pp) // 二级指针需要在前面使用**才能输出来值
}

传递指针到函数

通过给函数传入指针，可以修改对应地址变量的值

package main // 固定
import "fmt"

func swap(a *int, b *int) {
    var tmp int
    tmp = *a
    *a = *b
    *b = tmp
}

func main() { // 大括号的位置是固定的
    a:=10
    b:=99
    fmt.Println(a, b)
    swap(&a, &b)
    fmt.Println(a, b)
}

---

结构体

结构体的简单实用

package main // 固定
import "fmt"

// 定义一个结构体
type MyStruct struct{
    age int
    name string
    id int
}

func ShowStruct(myStruct MyStruct){
    fmt.Println(myStruct.id, myStruct.name, myStruct.age)
}

func main() { // 大括号的位置是固定的
    var myStruct MyStruct
    myStruct.age = 21
    myStruct.name = "zeng"
    myStruct.id = 11

    ShowStruct(myStruct)
}

结构体指针

package main // 固定
import "fmt"

// 定义一个结构体
type MyStruct struct{
    age int
    name string
    id int
}

func ShowStruct(myStruct MyStruct){
    fmt.Println(myStruct.id, myStruct.name, myStruct.age)
}

func main() { // 大括号的位置是固定的
    var myStruct MyStruct
    myStruct.age = 21
    myStruct.name = "zeng"
    myStruct.id = 11

    // 结构体指针的简单使用
    var pMyStruct *MyStruct
    pMyStruct = &myStruct

    ShowStruct(*pMyStruct)
}

---

切片

跟Python的切片其实差不多，都是可以看成数组的升级版

定义切片

package main // 固定
import "fmt"

func main() { // 大括号的位置是固定的
    // 切片的初始化
    s:=[]int {1, 2, 3}
    a:=s[:2] // 截取前面2个元素
    b:=make([]int, 2)
    b[0]=1
    b[1]=2
    fmt.Println(b[0], b[1])
    for index:=0; index<2; index++ {
        fmt.Println(a[index])
    }
}

len和cap函数

package main // 固定
import "fmt"

func main() { // 大括号的位置是固定的
    // 切片的初始化
    a:=make([]int, 2, 5) // 5表明切片最长可以达到多少
    c:=a[:5]
    //c:=a[:6] // cap在定义时候为5，则切片不能超过5
    fmt.Println(c)
    fmt.Println("len:%d cap=%d slice=%v\r\n", len(a), cap(a), a)
}

空切片

package main // 固定
import "fmt"

func main() { // 大括号的位置是固定的
    var number []int
    if (number == nil) {
        fmt.Println("空切片")
    }
}

切片截取

package main // 固定
import "fmt"

func main() { // 大括号的位置是固定的
    number := []int{0, 1, 2, 3, 4}
    fmt.Println(number[0:4]) // 包含上界不包含下界
    fmt.Println(number[:4])  // 上界不填默认为0
    fmt.Println(number[2:4]) // 包含上界不包含下界
}

append和copy函数

package main // 固定
import "fmt"

func main() { // 大括号的位置是固定的
    number := []int{0, 1, 2, 3, 4}
    // 向切片中添加单个元素
    number = append(number, 5)
    fmt.Println(number)
    // 向切片中添加多个元素
    number = append(number, 6, 7, 8)
    fmt.Println(number)
    // 创建切片number是之前切片的两倍容量
    number1 := make([]int, len(number), (cap(number))*2)
    // 拷贝number的内容到numbers1
    copy(number1, number)
    fmt.Println(number1, len(number1))
}

多维切片

使用到的时候在查看，其实就是切分多维数组

更多方法请参考

http://www.runoob.com/go/go-slice.html