go基础系列第二章 go函数和指针

内容导读

互联网集市收集整理的这篇技术教程文章主要介绍了go基础系列第二章 go函数和指针，小编现在分享给大家，供广大互联网技能从业者学习和参考。文章包含3936字，纯文字阅读大概需要6分钟。

内容图文

一. 指针

先来看一段代码

            var a int =2var pa *int
    pa = &a
    *pa = 3
    fmt.Println(a)

这里定义了一个int类型的变量a, 有定义了一个指针类型的变量pa, 让pa指向了a的地址. 然后修改了pa的值, 我们看看打印出来的a是什么:

结果:  3

下面开始描述指针

1. 指针也是一种变量, 指针变量的定义方式, 和普通变量的定义方式一样

2. go语言中的指针不能进行运算. 在c中,指针是可以运算的. 比如 &pa+2, 这在go中是不可以的. 还是刚才的例子,我们对指针进行运算, 编译就过不去

技术分享图片

3. go语言只有值传递, 没有引用传递. 如何实现go语言的引用传递呢, 配合指针.

如果你想要传递一个int类型的数值,如果是直接传递过去. 那么就是值拷贝. 如果想要引用传递, 那么就要把指针传递过去.

问题: 对象是值传递还是引用传递呢?

答案: 不一定. 如果你将一个对象Cache传递到一个函数里. 他是对这个Cache的一值copy么? 不一定. 要看这个函数里面的内部结构: 看下面的例子.

例子1:

            type Cache struct {
    aa int
    bb int
    cc string
}

func change(c Cache) {
    c.cc = "world"
    fmt.Println("in change, c", c)
}

func main() {
    // 初始化一个Cache对象
    var c = Cache{aa:1, bb:100, cc:"hello"}// 修改对象的值. 这里传递过去的是一个值拷贝    change(c)
    fmt.Println(c)
}

这个例子, 就是对象的一个值拷贝的过程. 修改了函数体里面对象的属性, 对函数外没有影响,

结果:

            in change, c {1 100 world}{1 100 hello}

例子2:

            type Cache struct {
    aa int
    bb int
    cc string
}

func change(c *Cache) {
    c.cc = "world"
    fmt.Println("in change, c", c)
}

func main() {
    // 初始化一个Cache对象
    var c = Cache{aa:1, bb:100, cc:"hello"}// 修改对象的值. 这里传递过去的是一个值拷贝
    change(&c)
    fmt.Println(c)
}

这个例子和例1不一样的地方是, 函数的参数是一个指针. 这就是引用传递, 修改函数体里面的值,外面也受影响.

返回结果:

            in change, c &{1 100 world}{1 100 world}

例子3:

            type Cache struct {
    aa int
    bb int
    cc *string
}

func change(c Cache) {
    *c.cc = "world"
    fmt.Println("in change, c", c.aa, c.bb, *c.cc)
}

func main() {
    // 初始化一个Cache对象
    cc := "hello"
    var c = Cache{aa:1, bb:100, cc:&cc}// 修改对象的值. 这里传递过去的是一个值拷贝    change(c)
    fmt.Println(c.aa, c.bb, *c.cc)
}

例子3: 和前两个例子不同的地方时, 结构体Cache中cc是一个地址. 他不是一个变量了. 那么这个时候. change函数修改了cc的值,会怎么样呢?

结果:

            in change, c 1100 world
1100 world

是的, cc是一个引用传递, 函数内改变了cc所在地址的值, 那么函数外也会改变

这就说明了, 结果体传递到函数里面, 到底是值传递还是引用传递呢? 和结构体内部的结构有关系.

3. 用go语言实现交换两个变量的值.

错误方法:

type Cache struct {
   aa int
   bb int
   cc *string
}
func change(a int ,b int) {
   a, b = b, a
   fmt.Println("in change, a:", a, ", b:", b)
}
func main() {
   // 初始化一个Cache对象
   a, b := 3, 4
   change(a, b)
   fmt.Println(a, b)
}

上述方法返回值:

in change, a: 4 , b: 3
3 4

错误的原因在于, int类型是值传递, 修改内容的值, 对外部没影响. 所以返回的还是3, 4

案例3: 使用指针

func change(a *int ,b *int) {
   fmt.Println(fmt.Println("[change---1], a:", a, ", b:", b))
   a, b = b, a
   fmt.Println("[change--2], a:", a, ", b:", b)
}
func main() {
   // 初始化一个Cache对象
   a, b := 3, 4
   fmt.Println("[main --- 1]", &a, &b)
   change(&a, &b)
   fmt.Println("[main --- 2]", a, b)
}

先来看输出结果:

[main --- 1] 0xc000096008 0xc000096010
[change---1], a: 0xc000096008 , b: 0xc000096010
48 <nil>
[change--2], a: 0xc000096010 , b: 0xc000096008
[main --- 2] 3 4

出乎意料, 原本以为, main函数最后的输出会是4, 3. 我们发现, 结果并不是. 也就是说, 虽然传的是指针过去, 但是是对指针的一个copy, 这一点更说明了, 所有的变量都是值拷贝. 包括指针变量. 也是一个值拷贝

案例4: 地址传递

func change(a *int ,b *int) {
    fmt.Println(fmt.Println("[change---1], a:", a, ", b:", b))
    *a, *b = *b, *a
    fmt.Println("[change--2], a:", a, ", b:", b)
}

func main() {
    // 初始化一个Cache对象
    a, b := 3, 4
    fmt.Println("[main --- 1]", &a, &b)
    change(&a, &b)
    fmt.Println("[main --- 2]", a, b)
}

案例4和三个不同之处, 是在change函数内, 修改了指针类型的变量的值. 输出结果是:

[main --- 1] 0xc00001c0f8 0xc00001c100
[change---1], a: 0xc00001c0f8 , b: 0xc00001c100
48 <nil>
[change--2], a: 0xc00001c0f8 , b: 0xc00001c100
[main --- 2] 43

我们看到, 最后的输出结果却是是4, 3

从这里我们得出以下结论:

1. 指针类型的变量, 和普通变量一样, 是值传递.

2. 指针类型的变量, 要向修改变量的值, 需要使用指针的指针来改变. 其实,在指针里面, 是指针的指针就是值了. 那么, 我们的原则是, 不管他是什么, 只有修改的是指针, 那么就是地址传递.

例子5: 还有一种更简单的交换两个值的方式

func change(a *int ,b *int) (int, int){
    return *b, *a
}

func main() {
    // 初始化一个Cache对象
    a, b := 3, 4
    fmt.Println("[main --- 1]", &a, &b)
    a,b = change(&a, &b)
    fmt.Println("[main --- 2]", a, b)
}

输出:

[main --- 1] 0xc00001c0f8 0xc00001c100
[main --- 2] 43

案例6: 最简单的方式

func change(a int ,b int) (int, int){
    return b, a
}

func main() {
    // 初始化一个Cache对象
    a, b := 3, 4
    fmt.Println("[main --- 1]", &a, &b)
    a,b = change(a, b)
    fmt.Println("[main --- 2]", a, b)
}

结果:

[main --- 1] 0xc000096008 0xc000096010
[main --- 2] 43

指针对于我们来说, 方便好多, 但是也会产生很对疑问. 比如案例5和案例6, 他们为什么得到的结果是一只呢?需要分析原因.

aaa

原文：https://www.cnblogs.com/ITPower/p/12047190.html

内容总结

以上是互联网集市为您收集整理的go基础系列第二章 go函数和指针全部内容，希望文章能够帮你解决go基础系列第二章 go函数和指针所遇到的程序开发问题。如果觉得互联网集市技术教程内容还不错，欢迎将互联网集市网站推荐给程序员好友。

内容备注

版权声明：本文内容由互联网用户自发贡献，该文观点与技术仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容，请发送邮件至 gblab@vip.qq.com 举报，一经查实，本站将立刻删除。

内容手机端

扫描二维码推送至手机访问。

本文链接：https://qyyshop.com/info/1224499.html

来源：【匿名】

【下一篇】php和golang的区别是什么？

更多 ►

【go基础系列第二章 go函数和指针】教程文章相关的互联网学习教程文章

一. 指针先来看一段代码var a int =2var pa *intpa = &a*pa = 3fmt.Println(a) 这里定义了一个int类型的变量a, 有定义了一个指针类型的变量pa, 让pa指向了a的地址. 然后修改了pa的值, 我们看看打印出来的a是什么:结果: 3 下面开始描述指针1. 指针也是一种变量, 指针变量的定义方式, 和普通变量的定义方式一样2. go语言中的指针不能进行运算. 在c中,指针是可以运算的. 比如 &pa+2, 这在go中是不可以的. 还是刚才的例子,我们对指...

golang-指针，函数，map【代码】

指针普通类型变量存的就是值，也叫值类型。指针类型存的是地址，即指针的值是一个变量的地址。一个指针只是值所保存的位置，不是所有的值都有地址，但是所有的变量都有。使用指针可以在无需知道变量名字的情况下，间接读取或更新变量的值。获取变量的地址，用&,例如:var a int 获取a的地址:&a，&a(a的地址)这个表达式获取一个指向整型变量的指针，它的类型是整形指针(*int),如果值叫做p,我们说p指向x,或者p包含x的地址，p指向的变量...

8.Go语言基础之指针【代码】【图】

Go语言中的指针不能进行偏移和运算，是安全指针。在了解GO语言中的指针前，首先需要知道三个概念：指针地址、指针类型和指针取值。1.Go语言中的指针任何数据载入内存后，在内存中都有对应的地址，这就是指针。为了保存一个数据在内存中的地址，需要指针变量。比如"好好学习，天天向上"这个字符串写入程序中，程序一启动这句话就加载到内存(假设内存地址为0x123456)，在程序中，把该字符串赋值给变量A，把该字符串的内存地址赋值...

go语言4 指针, 结构体, 方法, 接口, python链式调用【代码】

1 指针//指针：指针是一种存储变量内存地址（Memory Address）的变量。package mainfunc main() {//1 定义指针// 指向int类型的指针（指向什么类型指针，就是在什么类型前加星号）//var a *int//2 指针的零值 nil 引用类型//fmt.Println(a) // <nil>//3 使用指针//var a *int//var b int=100////a指针指向b （取谁的地址，就是在谁前面加一个&）//a=&b//fmt.Println(a)// ////4 了解（骚操作）////var c =&a//var c **int...

10、Go语言基础之指针【代码】【图】

区别于C/C++中的指针，Go语言中的指针不能进行偏移和运算，是安全指针。Go语言中的指针需要先知道3个概念：指针地址、指针类型和指针取值。1、Go语言中的指针任何程序数据载入内存后，在内存都有他们的地址，这就是指针。而为了保存一个数据在内存中的地址，就需要指针变量。Go语言中的指针不能进行偏移和运算，因此Go语言中的指针操作非常简单，只需要记住两个符号：&（取地址）和*（根据地址取值）。2、指针地址和指针类型每个变...

go结构，结构嵌套，接口，指针的测试和结论【代码】

package mainimport ("fmt" )//T是M1接受者，不是实现M2接受者 //*T是M1接受者，也是M2的接受者 //所以T对象不可以赋值给接口对象。*T可以//结论： // 1.结构T实现接口I时，如果想通过方法改变其属性，则需要*T实现I所有方法： // 2.嵌套结构时，编译器会将子结构的属性和方法拷贝给父结构，与子结构无关系了； // 3.赋值给接口对象I1，或者接口作为函数参数时,I1:=&T,因为是*T实现了接口I，否则报错 type T struct {Name string }...

Go -- go语言指针【代码】

package mainimport "fmt"type Test struct {Name string }func change2(t *Test) {t.Name = "2" }func change3(t *Test) {// !! 这里的量尽然改了//注意这里括号//如果直接*t.Name=3 编译不通过报错 invalid indirect of t.Name (type string)//其实在go里面*可以省掉，直接类似change2函数里这样使用。(*t).Name = "3" }func change4(t Test) {t.Name = "5" }func main() {// t 是一个地址t := &Test{Name:"1"}change2(t)fmt...

golang 碎片整理之指针【代码】

golang中保留了C中的值和指针的区别，但对于指针的繁琐用法进行了简化，引入了"引用"的概念，所以在go语言中，你不用担心因为直接操作内存而引起各式各样的错误。运算符只有 & 和，一个是取地址一个是取值（解析地址）。 func main(){var i inti = 1var p *intp = &ifmt.Printf("i=%d,p=%d,*p=%d\n",i,p,*p)*p =2fmt.Printf("i=%d,p=%d,*p=%d\n",i,p,*p)i = 3fmt.Printf("i=%d,p=%d,*p=%d\n",i,p,*p) }output:i=1,p=824634302464,...

Go 指针【代码】

普通指针：*T 对于任意类型 T，它所对应的指针类型就是 *T var i int var ip *intvar s string var sp *stringGo 是强类型，不同类型对应的 *T 不可相互转换、不可相互赋值、不可做比较、普通指针不可参与计算。万能指针：unsafe.Pointer unsafe.Pointer 与 *T 的关系，就好比 interface{} 和 T 的关系，也就是说 unsafe.Pointer 可以承载任意类型的 *T，它们之间可以互相转换，这就赋予了开发者直接操作指定内存的权力（效果不明...

Golang切片，数组，函数，结构体，指针【代码】

切片定义切片 //golang语言切片是对数组的抽象，长度不可改变与数组相比切片长度不固定，可以追加元素，追加可能使切片容量增大//切片初始化 var numbers = make([]int, 3, 5) fmt.Printf("len=%d cap=%d slice=%v\n", len(numbers), cap(numbers), numbers) //len=3 cap=5 slice=[0 0 0]//切片截取//创建切片x := []int{0, 1, 2, 3, 4, 5, 6, 7, 8}fmt.Printf("len=%d cap=%d slice=%v\n", len(x), cap(x), x)//len=9 cap=9 slice...

Golang指针

基本介绍 1）基本数据类型，变量存的就是值，也叫值类型 2）获取变量的地址，用&，比如：var num int ，获取num的地址：&num 3）指针类型，变量存的是一个地址，这个地址指向的空间存的才是值，比如：var ptr *int = &num 4) 获取指针类型所指向的值，使用：*，比如：var ptr *int ，使用 *ptr 获取p指向的值 5) 举例 var num int = 1 var i = 999 var ptr *int = &i

Go语言指针

一、什么是指针一个指针变量指向了一个值的内存地址。二、基本介绍基本数据类型的变量存的是值，也叫值类型指针类型的变量存的是一个地址，这个地址指向的空间存的才是值。例如：var ptr *int 获取变量的地址，用&，例如：var num int，获取num的地址，&num 获取指针类型变量所指向的值，使用*，例如：var ptr int，使用ptr获取ptr指向的值。

10天入门go语言教程- 指针

转载请注明来源"老男孩IT教育"来源网址：https://www.sholdboyedu.com/new/543.htmlGo 语言结构体 Go 语言中数组可以存储同一类型的数据,但在结构体中我们可以为不同项定义不同的数据类型。结构体是由一系列具有相同类型或不同类型的数据构成的数据集合。那么如何更好的学习go语言结构体呢，下面我们一起来看看吧！什么是结构体？结构体是用户定义的类型，表示若干个字段（Field）的集合。有时应该把数据整合在一起，而不是让这些...

Go语言基础之指针【代码】【图】

目录一、Go语言中的指针二、指针地址和指针类型三、指针取值四、new和make4.1 new4.2 make4.3 new与make的区别更新、更全的《Go从入门到放弃》的更新网站，更有python、go、人工智能教学等着你：https://www.cnblogs.com/nickchen121/p/11517502.html区别于C/C++中的指针，Go语言中的指针不能进行偏移和运算，是安全指针。要搞明白Go语言中的指针需要先知道3个概念：指针地址、指针类型和指针取值。一、Go语言中的指针Go语言中的函...

go语言的指针

写在前面：对于没有接触过或者刚刚接触指针的同学，阅读下面的文章还是挺有帮助的。简单粗暴：节省内存，提高程序运行效率。详细正文：<转载> Golang 为什么需要指针？这种指针又能有什么独特的用途呢？在学习引用类型语言的时候，总是要先搞清楚，当给一个函数/方法传参的时候，传进去的是值还是引用。实际上，在大部分引用型语言里，参数为基本类型时，传进去的大都是值，也就是另外复制了一份参数到当前的函数调用栈；...