指针
指针是代表某个内存地址的值。内存地址储存另一个变量的值。
指针（地址），一旦定义了不可改变，指针指向的值可以改变
go指针操作
1.默认值nil,没有NULL常量
2.操作符“&”取变量地址，“*“通过指针（地址）访问目标对象（指向值）
3.不支持指针运算，不支持“->”（箭头）运算符，直接用“.”访问目标成员
例子1:
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
|
package main //必须有个main包import "fmt"func main() { var a int = 10 //每个变量有2层含义：变量的内存，变量的地址 fmt.Printf("a = %d\n", a) //变量的内存 fmt.Printf("&a = %d\n", &a) //保存某个变量的地址，需要指针类型 *int 保存int的地址， **int 保存 *int 地址 //声明(定义)， 定义只是特殊的声明 //定义一个变量p, 类型为*int var p *int p = &a //指针变量指向谁，就把谁的地址赋值给指针变量 fmt.Printf("p = %v, &a = %v\n", p, &a) *p = 666 //*p操作的不是p的内存，是p所指向的内存(就是a) fmt.Printf("*p = %v, a = %v\n", *p, a)} |
例子2:
|
1
2
3
4
5
6
7
8
|
package mainimport "fmt"func main() { a := 10 b := &a *b = 11111 //操作指向a的值 fmt.Println(a) //11111} |
不能操作不合法指向
|
1
2
3
4
5
6
7
8
9
10
11
12
13
|
package main //必须有个main包import "fmt"func main() { var p *int p = nil fmt.Println("p = ", p) //*p = 666 //err, 因为p没有合法指向 var a int p = &a //p指向a *p = 666 fmt.Println("a = ", a)} |
new函数
表达式new(int)将创建一个int类型的匿名变量,为int类型的新值分配并清零一块内存空间，然后将这块内存空间的地址作为结果返回，而这个结果就是指向这个新的int类型值的指针值，返回的指针类型为*int
|
1
2
3
4
5
6
7
8
9
10
|
package mainimport "fmt"func main() { //var a *int a := new(int) // a为*int类型，指向匿名的int变量 fmt.Println(*a) // 0 b := new(int) // b为*int类型，指向匿名的int变量 *b = 2 fmt.Println(*b) // 2} |
我们只需要使用new()函数，无需担心内存的生命周期，和回收删除。因为GO语言的（gc）内存管理系统会帮我们处理。
指针做函数的参数
例子1:交换值,普通变量做函数参数。内部交换成功，外部失败
|
1
2
3
4
5
6
7
8
9
10
11
12
|
package main //必须有个main包import "fmt"func swap(a, b int) { a, b = b, a fmt.Printf("swap: a = %d, b = %d\n", a, b) //swap: a = 20, b = 10}func main() { a, b := 10, 20 //通过一个函数交换a和b的内容 swap(a, b) //变量本身传递，值传递（站在变量角度） fmt.Printf("main: a = %d, b = %d\n", a, b) //main: a = 10, b = 20} |
例子2:指针传参，内部外部都交换成功
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
|
package main //必须有个main包import ( "fmt")func test(a, b *int) { *a, *b = *b, *a fmt.Printf("swap: a = %d, b = %d\n", *a, *b)}func main() { a, b := 10, 20 ////通过一个函数交换a和b的内容 test(&a, &b) fmt.Printf("main: a = %d, b = %d\n", a, b)} |
数组指针
//(*p)[0] = 666 数组指针赋值
|
1
2
3
4
5
6
7
8
9
10
11
12
13
|
package main //必须有个main包import "fmt"//p指向实现数组a，它是指向数组，它是数组指针//*p代表指针所指向的内存，就是实参afunc modify(p *[5]int) { (*p)[0] = 666 fmt.Println("modify *a = ", *p) //modify *a = [666 2 3 4 5]}func main() { a := [5]int{1, 2, 3, 4, 5} //初始化 modify(&a) //地址传递 fmt.Println("main: a = ", a) // modify *a = [666 2 3 4 5]} |
结构体指针变量
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
|
package main //必须有个main包import "fmt"//定义一个结构体类型type Student struct { id int name string sex byte //字符类型 age int addr string}func main() { //顺序初始化，每个成员必须初始化, 别忘了& var p1 *Student = &Student{1, "mike", 'm', 18, "bj"} fmt.Println("p1 = ", p1) //p1 = &{1 mike 109 18 bj} //指定成员初始化，没有初始化的成员，自动赋值为0 p2 := &Student{name: "mike", addr: "bj"} fmt.Printf("p2 type is %T\n", p2) //p2 type is *main.Student fmt.Println("p2 = ", p2) //p2 = &{0 mike 0 0 bj}} |
结构体成员普通变量
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
|
//定义一个结构体类型type Student struct { id int name string sex byte //字符类型 age int addr string}func main() { //定义一个结构体普通变量 var s Student //操作成员，需要使用点(.)运算符 s.id = 1 s.name = "mike" s.sex = 'm' //字符 s.age = 18 s.addr = "bj" fmt.Println("s = ", s) //s = {1 mike 109 18 bj}} |
结构体成员指针变量
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
|
func main() { //1、指针有合法指向后，才操作成员 //先定义一个普通结构体变量 var s Student //在定义一个指针变量，保存s的地址 var p1 *Student p1 = &s //通过指针操作成员 p1.id 和(*p1).id完全等价，只能使用.运算符 p1.id = 1 (*p1).name = "mike" p1.sex = 'm' p1.age = 18 p1.addr = "bj" fmt.Println("p1 = ", p1) //2、通过new申请一个结构体 p2 := new(Student) p2.id = 1 p2.name = "mike" p2.sex = 'm' p2.age = 18 p2.addr = "bj" fmt.Println("p2 = ", p2)} |
结构体比较和赋值
|
1
2
3
4
5
6
7
8
9
10
11
|
func main() { s1 := Student{1, "mike", 'm', 18, "bj"} s2 := Student{1, "mike", 'm', 18, "bj"} s3 := Student{2, "mike", 'm', 18, "bj"} fmt.Println("s1 == s2 ", s1 == s2) fmt.Println("s1 == s3 ", s1 == s3) //同类型的2个结构体变量可以相互赋值 var tmp Student tmp = s3 fmt.Println("tmp = ", tmp)} |
结构体作为函数参数
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
|
func test02(p *Student) { p.id = 666}func main() { s := Student{1, "mike", 'm', 18, "bj"} test02(&s) //地址传递（引用传递），形参可以改实参 fmt.Println("main: ", s)}func test01(s Student) { s.id = 666 fmt.Println("test01: ", s)}func main01() { s := Student{1, "mike", 'm', 18, "bj"} test01(s) //值传递，形参无法改实参 fmt.Println("main: ", s)} |
以上就是go语言结构体指针操作示例详解的详细内容，更多关于go语言结构体指针的资料请关注服务器之家其它相关文章！
原文链接：https://www.cnblogs.com/guyouyin123/p/13938347.html
