我们学过了基础数据类型 现在学习下复合类型

复合类型：把基础类型封装起来了 。

指针

指针可是c语言中的重头戏，指针数组 数组指针 函数指针 指针函数 回调函数 回调函数的数组 一级指针二级指针三四五 。。。。c语言指针有可以进行判断 进行+-等操作 go语言是不行的

go语言弱化了指针，最多只有二级指针

基础数据类型存放的是值 数

指针存放的是地址，切记是地址

package main

import "fmt"

func main() {

    var a int = 10
    var p  *int = &a

    fmt.Println(p)
    fmt.Println(&a)
}

&就是取地址的意思 &a吧a的地址取出来给了p

指针定义了最好要初始化，要不然后期用了 忘记赋值可就成了野指针

结果  因为p存放的是a的地址 所以地址是一样的

我们如何取出p地址的值那

package main

import "fmt"

func main() {

    var a int = 10
    var p  *int = &a

    fmt.Println(p)
    fmt.Println(&a)

    fmt.Println(*p)
    fmt.Println(a)

}

我们可以用*的方法吧p存的地址值取出来。

结果就是10 10了 

我们再来看看二级指针

package main

import "fmt"

func main() {

    var a int = 10
    var p  *int = &a
    var pp ** int = &p

    fmt.Println(&a)
    fmt.Println(p)
    fmt.Println(*pp)

    fmt.Println(&p)
    fmt.Println(pp)



}

 我们来分析下这段代码，前三个都是打印的a的地址

&a是a的地址毋庸置疑 p存的也是a的地址 pp存放的是p的地址 *pp就是取出p的值也就是a的地址

最后两行 打印的都是p的地址，&p就是p的地址 pp 也是p的值

函数本身也是一种类型，学完了函数来学习闭包函数吧

闭包函数

package main

import "fmt"

func main() {
    a := getStack("龙玉1")
    b := getStack("龙玉2")

    c := a(10)
    d := b(20)

    c = a(10)
    d = b(20)

    fmt.Println(&a, c)
    fmt.Println(&b, d)
//  a 存放的是局部函数的地址
//  b也是存放的匿名函数的地址
//a() b()也就是执行匿名函数
// sum相对于匿名函数来说 则是全局变量，所以sum的被保留了
}

func getStack(name string, ) func(min int) int {
    var sum int = 0

    a := func(min int) int {
        sum += min
        return sum
    }
    return a
}

 函数里面包含一个匿名函数 函数里面的局部变量相对于匿名函数来说 也是全局变量，它会把这个值保存起来，应该是根据执行函数的地址 来存放起来。

具体的我不是很懂，后期需要继续查资料

数组

数组是一片连续的内存存放同种数据类型的一种容器

如下就是开辟可以放五个整型的数组

package main

import "fmt"

func main() {

    var array [5]int = [5]int {1,2,3,4,5}

    fmt.Println(array)
}

打印的结果为 1 2 3 4 5

数组可以放任何类型 包含复合后面 指针都可以

package main

import "fmt"

func main() {

    a := 1
    b := 2
    c := 3
    d := 4
    e := 5

    var parray [5]* int = [5]*int{&a,&b,&c,&d,&e}

    fmt.Println(parray)
}

打印a b c d e 的地址