Go语言指针与结构体

初识指针

func main() {
	var a int = 10
	var b = &a
	fmt.Println("a的值为", a)
	fmt.Println("a的内存地址为", &a)
	fmt.Println("b的值为", b)
	//*指针
	fmt.Println("变量b指向内存地址中存储的数据", *b)
	*b = 20
	fmt.Println(a, *b)

}

指针的使用

func main() {
	var a int = 10
	fmt.Println(a)
	fmt.Println("a的内存地址", &a)
	//声明一个指针变量
	var p *int
	p = &a
	fmt.Println(&a)
	fmt.Printf("p 变量储存的指针地址：%p\n", p)
	fmt.Printf("p 变量的地址%p\n", &p)
	*p = 20
	fmt.Println(a)
	//在定义一个指针变量ptr ，来指向 指针变量p
	var ptr **int
	ptr = &p
	fmt.Printf("ptr 变量储存的指针地址:%p\n", ptr)
	fmt.Printf("ptr 变量自己的地址%p\n", &ptr)
	fmt.Printf("*ptr变量的值 %p\n", *ptr)
	fmt.Printf("*ptr 变量的地址的值%d\n", **ptr)

}

10
a的内存地址 0xc00001a0a8
0xc00001a0a8
p 变量储存的指针地址：0xc00001a0a8
p 变量的地址0xc00000a030
20
ptr 变量储存的指针地址:0xc00000a030
ptr 变量自己的地址0xc00000a038
*ptr变量的值 0xc00001a0a8
*ptr 变量的地址的值20

指针与数组

func main() {
	//数组指针
	arr1 := [4]int{1, 2, 3, 4}
	var p1 *[4]int
	p1 = &arr1
	fmt.Printf("p1->地址:%p\n", p1)
	fmt.Printf("p1地址:%p\n", &p1)
	fmt.Printf("p1->地址->值:%d\n", *p1)

	(*p1)[0] = 100
	fmt.Println(arr1)
	fmt.Println(*p1)

	//简化写法,指向谁，代表谁
	p1[0] = 200
	fmt.Println(arr1)
	fmt.Println(*p1)
	a := 1
	b := 1
	c := 1
	d := 1
	arr2 := [4]*int{&a, &b, &c, &d}
	fmt.Println(arr2)
	fmt.Println(*arr2[1])

}

p1->地址:0xc0000121c0
p1地址:0xc00000a028
p1->地址->值:[1 2 3 4]
[100 2 3 4]
[100 2 3 4]
[200 2 3 4]
[200 2 3 4]
[0xc00001a0a8 0xc00001a0e0 0xc00001a0e8 0xc00001a0f0]
1

指针与函数

func main() {
	ptr := f1()
	fmt.Printf("ptr的类型%T\n", ptr)
	fmt.Println("ptr的地址", &ptr)
	fmt.Println("ptr->指向地址的值", *ptr)
	fmt.Println(ptr[0])
	a := 10
	f2(&a)
	fmt.Println(a)
}

// 数组型函数指针
func f1() *[4]int {
	arr := [4]int{1, 2, 3, 4}
	return &arr
}
func f2(ptr *int) {
	fmt.Println("ptr", ptr)
	fmt.Println("*ptr", *ptr)
	*ptr = 100
}

ptr的类型*[4]int
ptr的地址 0xc00000a028
ptr->指向地址的值 [1 2 3 4]
1
ptr 0xc00001a0e0

结构体的定义和使用

// User 权限；小写私有，大写：公开
type User struct {
	name string
	age  int
	sex  string
}

func main() {
	//创建一些对象
	var user User
	fmt.Println(user)
	user.name = "周南"
	user.age = 18
	user.sex = "男"
	fmt.Println(user)
	fmt.Println(user.name)
	user2 := User{}
	user2.name = "周"
	user2.age = 18
	user2.sex = "男"
	fmt.Println(user2)
	fmt.Println(user2.name)
	user3 := User{"南", 4, "男"}
	fmt.Println(user3)

}

结构体指针运用

//结构体指针
//使用内置函数new()创建，new的所有的Type都返回指针
//user1:=new（User）
//结构体是值传递

type User struct {
	name string
	age  int
	sex  string
}

func main() {
	user1 := User{"周南", 18, "男"}
	user2 := user1
	user2.name = "打阿伟"
	fmt.Println(user1)
	fmt.Println(user2)
	//指针
	var user3 *User
	user3 = &user1
	user3.name = "玩云桑"
	fmt.Printf("user1的地址%p\n", &user1)
	fmt.Printf("user2的地址%p\n", &user2)
	fmt.Printf("user3的地址%p\n", user3)

	fmt.Println(*user3)
	fmt.Println(user1)
	fmt.Println(user2)

	user4 := new(User)
	fmt.Printf("%T\n", user4)
	user4.name = "zhounan"
	user4.age = 18
	user4.sex = "男"
	fmt.Println(*user4)

}

匿名结构体

//Student

type Student struct {
	name string
	age  int
}
type Teacher struct {
	string
	int
}

// 匿名结构体
func main() {

	s1 := Student{"周南", 18}
	fmt.Println(s1)
	s2 := struct {
		name string
		age  int
	}{
		name: "周南",
		age:  12,
	}
	fmt.Println(s2)
	s2.name = "玩云桑"
	fmt.Println(s2)
	s3 := Teacher{"打阿伟", 18}
	fmt.Println(s3)
	//匿名字段，默认用字段数据类型当字段名称
	fmt.Println(s3.string)
	fmt.Println(s3.int)

}

结构体嵌套

//结构体嵌套

type Person struct {
	name    string
	age     int
	address Address
}
type Address struct {
	city, state string
}

func main() {
	var person = Person{}
	person.name = "周南"
	person.age = 18
	person.address = Address{"怀德", "中国"}
	fmt.Println(person)

	person1 := Person{"打阿伟", 12, Address{"怀德", "中国"}}
	fmt.Println(person1)
	fmt.Println(person1.address.city)

}

结构体的挎包调用

import (
	"./pojo"
	"fmt"
)

func main() {
	var user pojo.User
	user.Name = "狂神"
	user.Money = "100"
	user.Age = 25
	fmt.Println(user)
}

package pojo

type User struct {
	Name  string
	Age   int
	Money string
}
type cat struct {
	age int
}

环境要配好