go语言学习（四）

1.指针

2.数组

3.切片

4.字典

一、指针定义，操作

package main

import "fmt"

func main() {

    var a int = 10

    //定义一个指针类型的变量

    var p *int

    //&为取地址符，取a的地址赋值给p

    p = &a

    fmt.Println(p)

    fmt.Println(&a) //此处打印a的地址与p的值相同

    fmt.Println("操作之前a = ", a)

    *p = 111 //操作的其实是p所指向的a的内存

    fmt.Println("操作之后a = ", a)

}

p保存的是a的地址，*p指针指向的是a的内存

二、指针作为参数传递

package main

import "fmt"

func test_1(a int) {

    a++

}

func test_2(a *int) {

    *a++

}

func main() {

    var a int

    test_1(a)

    fmt.Println("test_1操作后", a)

    test_2(&a)

    fmt.Println("test_2操作后", a)

}

输出结果为     test_1操作后 0  test_2操作后 1

test_1方法，其传参形式属于值传递，a作为形参，作用域仅在该方法中。test_2方法为地址传递，操作的为a的内存，所以test_2方法会修改a的值，使用指针作为参数传递，可以让主函数知道其他函数所做的操作。

三、数组

数组是同一种类型数据的集合，数组中的每一个数据称为元素。

package main

import "fmt"

func main() {

    //定义一个长度为50的数组

    var a [50]int

    //通过for循环向数组中添加元素

    for i := 0; i < len(a); i++ {

        a[i] = i + 1

    }

    //通过range迭代a，返回两个参数index为数组下标，data为下标对应的数据

    for index, data := range a {

        fmt.Printf("a[%d]的值为:%d\n", index, data)

    }

    //定义一个数组并赋值

    b := [5]int{1, 2, 3, 4, 5}

    fmt.Println(b[2])

    b[2] = 666 //修改数组中的第0个元素为666

    fmt.Println(b[2])

    //指定数组中的某个元素初始化

    c := [5]int{2: 10}

    fmt.Println(c) //打印结果为[0 0 10 0 0]

}

四、切片

数组的长度在定义之后无法修改，go语言引入切片的设计，通过内部指针和相关属性引用数组片段，实现可变长度。

package main

import "fmt"

func main() {

    //定义一个切片a

    var a []int

    fmt.Printf("a 的长度为 %v ,a的容量为 %v \n", len(a), cap(a))

    //切片的长度是可变的，当长度与容量相同时，切片会自动扩容，变为当前容量的2倍

    //append方法向切片末尾追加数据

    for i := 0; i < 5; i++ {

        a = append(a, i+1)

        fmt.Printf("a 的长度为 %v ,a的容量为 %v \n", len(a), cap(a))

    }

    fmt.Println(a)

}

打印结果为：

a 的长度为 0 ,a的容量为 0a 的长度为 1 ,a的容量为 1a 的长度为 2 ,a的容量为 2a 的长度为 3 ,a的容量为 4a 的长度为 4 ,a的容量为 4a 的长度为 5 ,a的容量为 8

[1 2 3 4 5]

如果一个切片没有添加数据，并且有长度，初始化时会向切片中添加默认值；

append方法会在切片的末尾追加数据，如果切片中有默认值，就会追加到默认值之后；

package main

import "fmt"

func main() {

    //定义切片

    a := []int{1, 2, 3, 4, 5}

    fmt.Println(a)

    //从a中截取下标从1到3的元素，返回的b也是一个切片，长度为3-1，容量为5-1

    b := a[1:3:5]

    fmt.Println(b)

    fmt.Printf("b 的长度为 %v ,b 的容量为 %v \n", len(b), cap(b))

    //其他定义切片的方法

    //定义一个长度为5，容量为10的切片

    c := make([]int, 5, 10)

    fmt.Printf("c 的长度为 %v ,c 的容量为 %v \n", len(c), cap(c))

    //当不指定容量时，默认容量与长度相同

    d := make([]int, 5)

    fmt.Printf("d 的长度为 %v ,c 的容量为 %v \n", len(d), cap(d))

}

进行切片时，容量不能大于模板切片的容量，代码中的b:=a[1:3:5]，[]中的数据都不能大于a的容量.

copy函数使用：

package main

import "fmt"

func main() {

    //定义切片

    a := []int{1, 2}

    b := []int{6, 6, 6, 6, 6, 6}

    copy(b, a)

    fmt.Println(a)

    fmt.Println(b)

}

输出结果为：

[1 2]
[1 2 6 6 6 6]

copy函数将a切片中的值复制到了b切片中的相应位置

五、字典

map是一种内置的数据结构，它是一个无序的key—value的集合。

声明一个map： var    name    map[keyType] valueType { }

package main

import "fmt"

func main() {

    //map定义

    a := map[int]string{}

    fmt.Println("a 的长度:", len(a))

    //使用make定义map

    b := make(map[string]string)

    fmt.Println("b 的长度:", len(b))

}

map的基本操作

package main

import "fmt"

import "strconv"

func main() {

    //map定义

    a := map[int]string{}

    //向map中添加数据a[key] = value

    for i := 0; i < 5; i++ {

        a[i] = strconv.Itoa(i)

    }

    //遍历map

    for key, value := range a {

        fmt.Printf("a[%d] = %v \n", key, value)

    }

    //删除键值为1的元素

    delete(a, 1)

    fmt.Println(a)

}