Go速成无压力【六】：指针，结构，数组（pointer, struct , array）

（一）指针 (Pointer)

Go拥有自己的指针，一个指针保留了值的内存地址
比如：*P 是指向 P这个变量的值，如果一个指针定义声明了但是没有被赋值，没有指向，则它的值可以写为 nil

（1）指针的定义

var p *int

（2）指针的地址

使用 & 操作符可以引出指针的值，如果指针被改变值，则该指针所绑定的值必然被改变，因为所绑定的值和指针指向的是同一个地址

fmt.Printf(&p)

（3）指针的赋值

指针的赋值依靠 * 操作符 ，比如：

*p = 12

和c 语言不同， go语言没有指针运算

（4）指针的操作——实战演示

实战1：

package main

import "fmt"

func main() {
	// 使用变量地址给指针赋值
	x := 12
	p := &x
	fmt.Println("指针p的值为：", *p)
	fmt.Println("指针p的地址为：", &p)

	// 定义指针并赋值
	var t *int
	t = &x
	fmt.Println("指针t的值为：", *t)
}

实战2：

如果指针被改变值，则该指针所绑定的值必然被改变，因为所绑定的值和指针指向的是同一个地址

package main

import "fmt"

func main() {
	var p *int
	var y int = 1024
	p = &y
	fmt.Println("指针p被改变前的值为：", *p)
	fmt.Println("指针p被改变前，y值为：", y)
	*p += 1024
	fmt.Println("指针p被修改后的值为：", *p)
	fmt.Println("指针p被改变前，y值为：", y)
}

---

（二）结构（struct）

结构是一个域的集合，这里的域可以表示为很多变量, 结构采用关键字struct表示

package main
import "fmt"
type Vertex struct {
	x int
	y int
}

func main(){
	fmt.Println(Vertex{1,2})
}

---

（三）结构体的使用

使用结构体内的成员，需要用到符号 . ,先给结构体赋值，然后再使用 . 操作符

package main
import "fmt"

type zoo struct{
	Monkey string
	bird string
	elephant string
}

func main(){
	zoo {"金丝猴","火烈鸟","PHP"}
	fmt.Println(zoo.Monkey , zoo.bird , zoo.elephant)
}

---

（四）指向结构体的指针

结构体的成员可以被指针指向
使用指针 p 调用结构体的成员x的写法为 (*p).x ， 还可以写为 p.x

package main

import "fmt"

type Vertex struct {
	x int
	y int
}

func main() {
	v := Vertex{1, 2}
	p := &v
	p.x = 1e12
	fmt.Println("结构体v为：", v)
	fmt.Println("p指针为：", p)
}

---

（五）结构体的各种赋值

结构体可以用 名字:变量 的方式进行赋值

package main

import "fmt"

type Vertex struct {
	x, y int
}

func main() {
	var (
		v1 = Vertex{1, 10}  //给Vertex结构体的全体成员赋值
		v2 = Vertex{}       //结构体成员全部被赋值为0
		v3 = Vertex{y: 10}  //只给y赋值为10，x默认为0
		p  = &Vertex{99, 1} //赋值后被指针指向
	)

	fmt.Println(p, v1, v2, v3) //输出结果
}

---

（六）数组（array）

数组的表达式为：var 数组名[数组数量] 类型

声明一个类型为整型，数组名为a，数组长度为10的数组

var a[10] int

（1）数组操作的演示

package main
import "fmt"
func main(){
	var a[10] int
	a[0] = 10
	a[8] = 20
	fmt.Println("输出指定下标的数组>>>  ",a[0],a[8]) //输出指定下标的数组
	fmt.Println("输出整个数组>>> ",a) //输出整个数组

	for n :=0 ; n<10 ; n++ {
		a[n] = n*11
	}
	fmt.Println("数组被遍历赋值后，输出整个数组>>> ",a) //数组被遍历赋值后，输出整个数组
}

数组的长度是其类型的一部分，所以数组的尺寸不能被重置，这使数组看起来似乎是有限的，但是不要担心，Go提供了一个使用数组更快捷的方法

（2）未指定数组长度时的赋值操作

package main

import "fmt"

func main() {
	//数组未设置具体长度时
	b := []int{1, 3123, 123, 123, 12, 3}
	fmt.Println(b)

	//对上面未设置具体长度的数组b动态添加一位新的成员时
	b = []int{45, 45, 45, 55, 45, 78, 99}
	fmt.Println(b)
}

数组可以正常赋值，随意改变数组数据与长度

（3）指定数组长度后的赋值操作

package main

import "fmt"

func main() {
	a := [9]int{1, 2, 3, 45, 12, 32, 1, 32, 12}
	fmt.Println(a)
	a = [10]int{1, 2, 3, 45, 12, 32, 1, 32, 12, 999}
	fmt.Println(a)
}

运行后，可见结果报错，被设置了固定长度的数组无法改变其长度，否则会报错