初识指针
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
}