来源：蜘蛛抓取(WebSpider)
时间：2017-11-26 14:06
标签：
修车师傅建议买哪款车
简述go函数的传值与传指针 - 简书
简述go函数的传值与传指针
传值当传一个参数值到被调用函数里面时，实际上是传递了这个值的一份copy拷贝&&所以在被调用函数里修改参数值时，调用函数中相应的实参不会发生任何变化，因为数值变化只作用在拷贝copy上。
当我们调用函数add的时候，add接收的参数其实是x的copy，而不是x本身
copy使用过程
传指针接下来解决如何把x本身传入，即达到真正改变x值的效果立马想到要去获取变量的内存地址：&x，通过内存地址就能真正的修改x的值如何使用呢？我们需要将x所在地址&x传入函数，并将函数的参数的类型由int改为*int，即改为指针类型，才能在函数中修改x变量的值。
传指针实现通过函数修改变量的目的
传指针的好处1.传指针使得多个函数能操作同一个对象。2.传指针比较轻量级 (8bytes),只是传内存地址，我们可以用指针传递体积大的结构体。如果用参数值传递的话, 在每次copy上面就会花费相对较多的系统开销（内存和时间）。所以当你要传递大的结构体的时候，用指针是一个明智的选择。3.Go语言中channel，slice，map这三种类型的实现机制类似指针，所以可以直接传递，而不用取地址后传递指针。（注：若函数需改变slice的长度，则仍需要取地址传递指针）
不在孤独中迷失， 就在孤独中成长， 独，善其身...Go语言中普通函数与方法的区别分析
作者：books1958
字体：[ ] 类型：转载 时间：
这篇文章主要介绍了Go语言中普通函数与方法的区别,以实例形式对比分析了普通函数与方法使用时的区别与相关技巧,需要的朋友可以参考下
本文实例分析了Go语言中普通函数与方法的区别。分享给大家供大家参考。具体分析如下：
1.对于普通函数，接收者为值类型时，不能将指针类型的数据直接传递，反之亦然。
2.对于方法（如struct的方法），接收者为值类型时，可以直接用指针类型的变量调用方法，反过来同样也可以。
以下为简单示例：
代码如下:package structTest&
//普通函数与方法的区别（在接收者分别为值类型和指针类型的时候）&
//Date： 10:00:07&
&&& "fmt"&
func StructTest06Base() {&
&&& structTest0601()&
&&& structTest0602()&
//1.普通函数&
//接收值类型参数的函数&
func valueIntTest(a int) int {&
&&& return a + 10&
//接收指针类型参数的函数&
func pointerIntTest(a *int) int {&
&&& return *a + 10&
func structTest0601() {&
&&& a := 2&
&&& fmt.Println("valueIntTest:", valueIntTest(a))&
&&& //函数的参数为值类型，则不能直接将指针作为参数传递&
&&& //fmt.Println("valueIntTest:", valueIntTest(&a))&
&&& //compile error: cannot use &a (type *int) as type int in function argument&
&&& b := 5&
&&& fmt.Println("pointerIntTest:", pointerIntTest(&b))&
&&& //同样，当函数的参数为指针类型时，也不能直接将值类型作为参数传递&
&&& //fmt.Println("pointerIntTest:", pointerIntTest(b))&
&&& //compile error:cannot use b (type int) as type *int in function argument&
type PersonD struct {&
&&& id&& int&
&&& name string&
//接收者为值类型&
func (p PersonD) valueShowName() {&
&&& fmt.Println(p.name)&
//接收者为指针类型&
func (p *PersonD) pointShowName() {&
&&& fmt.Println(p.name)&
func structTest0602() {&
&&& //值类型调用方法&
&&& personValue := PersonD{101, "Will Smith"}&
&&& personValue.valueShowName()&
&&& personValue.pointShowName()&
&&& //指针类型调用方法&
&&& personPointer := &PersonD{102, "Paul Tony"}&
&&& personPointer.valueShowName()&
&&& personPointer.pointShowName()&
&&& //与普通函数不同，接收者为指针类型和值类型的方法，指针类型和值类型的变量均可相互调用&
希望本文所述对大家的Go语言程序设计有所帮助。
您可能感兴趣的文章:
大家感兴趣的内容
12345678910
最近更新的内容
常用在线小工具Go语言之函数方法_Linux编程_Linux公社-Linux系统门户网站
你好，游客
Go语言之函数方法
来源：Linux社区&
作者：babyshen
在Go语言中，函数和方法不太一样，有明确的概念区分。在其他语言中，比如Java，一般来说，函数就是方法，方法就是函数。但是在Go语言中，函数是指不属于任何结构体、类型的方法。也就是说，函数是没有接收者的；而方法是有接收者的。我们说的方法要么是属于一个结构体的，要么属于一个新定义的类型的。
函数和方法，虽然概念不同，但是定义非常相似。函数的定义声明没有接收者，所以我们直接在Go文件里、Go包之下定义声明即可。
func&main()&{
& & sum&:=&add(1,&2)
& & fmt.Println(sum)
func&add(a,&b&int)&int&{
& & return&a&+&b
例子中，我们定义了add就是一个函数，它的函数签名是func add(a, b int) int。没有接收者，直接定义在Go的一个包之下，可以直接调用，比如例子中的main函数调用了add函数。
例子中的这个函数名称是小写开头的add，所以它的作用域只属于所声明的包内使用，不能被其他包使用。如果我们把函数名以大写字母开头，该函数的作用域就大了，可以被其他包调用。这也是Go语言中大小写的用处。比如Java中，就有专门的关键字来声明作用域private、protect、public等。
&提供的常用库，有一些常用的方法，方便使用
package&lib
//&一个加法实现
//&返回a+b的值
func&Add(a,&b&int)&int&{
& & return&a&+&b
如上例子中定义的Add方法就可以被其他包调用。
方法的声明和函数类似，他们的区别是：方法在定义的时候，会在func和方法名之间增加一个参数，这个参数就是接收者，这样我们定义的这个方法就和接收者绑定在了一起，称之为这个接收者的方法。
type&person&struct&{
& & name&string
func&(p&person)&String()&string{
& & return&"the&person&name&is&"+p.name
留意例子中，func和方法名之间增加的参数(p person)，这个就是接收者。现在我们说，类型person有了一个String方法，现在我们看下如何使用它。
func&main()&{
& & p:=person{name:"张三"}
& & fmt.Println(p.String())
调用的方法非常简单，使用类型的变量进行调用即可，类型变量和方法之前是一个.操作符，表示要调用这个类型变量的某个方法的意思。
Go语言里有两种类型的接收者：值接收者和指针接收者。上面就是使用值类型接收者的示例。
使用值类型接收者定义的方法，它调用的其实是值接收者的一个副本，所以对该值的任何操作，不会影响原来的类型变量。
func&main()&{
& & p:=person{name:"张三"}
& & p.modify()&//值接收者，修改无效
& & fmt.Println(p.String())
type&person&struct&{
& & name&string
func&(p&person)&String()&string{
& & return&"the&person&name&is&"+p.name
func&(p&person)&modify(){
& & p.name&=&"李四"
以上的例子，打印出来的值还是张三，对其进行的修改无效。如果我们使用一个指针作为接收者，那么就会其作用了。因为指针接收者传递的是一个指向原值指针的副本，它指向的还是原来类型的值，所以修改时，同时也会影响原来类型变量的值。
func&main()&{
& & p:=person{name:"张三"}
& & p.modify()&//指针接收者，修改有效
& & fmt.Println(p.String())
type&person&struct&{
& & name&string
func&(p&person)&String()&string{
& & return&"the&person&name&is&"+p.name
func&(p&*person)&modify(){
& & p.name&=&"李四"
只需要改动一下，变成指针的接收者，就可以完成修改。
在调用方法的时候，传递的接收者本质上都是副本，只不过一个是这个值副本，一个是指向这个值指针的副本。指针具有指向原有值的特性，所以修改了指针指向的值，也就修改了原有的值。我们可以简单地理解为值接收者使用的是值的副本来调用方法，而指针接收者使用实际的值来调用方法。
有没有发现，在上面的例子中，我们在调用指针接收者方法的时候，使用的也是一个值的变量，并不是一个指针。如果我们使用下面的方法也是可以的。
p:=person{name:"张三"}
(&p).modify()&//指针接收者，修改有效
如果我们没有这么强制使用指针进行调用，Go的编译器会自动帮我们取指针，以满足接收者的要求。
同样的，如果是一个值接收者的方法，使用指针也是可以调用的。Go编译器会自动解引用，以满足接收者的要求。比如例子中定义的String()方法，也可以这么调用：
p:=person{name:"张三"}
fmt.Println((&p).String())
总之，方法的调用，既可以使用值，也可以使用指针。我们不必要严格的遵守这些，Go语言编译器会帮我们进行自动转义的，这大大方便了我们开发者。
不管是使用值接收者，还是指针接收者，一定要搞清楚类型的本质：对类型进行操作的时候，是要改变当前值，还是要创建一个新值进行返回？这些就可以决定我们是采用值传递，还是指针传递。
Go语言支持函数方法的多值返回，也就说我们定义的函数方法可以返回多个值。比如标准库里的很多方法，都是返回两个值：第一个是函数需要返回的值，第二个是出错时返回的错误信息。这样的好处是，我们的出错异常信息再也不用像Java一样，需要使用Exception这么重的方式表示了，非常简洁。
func&main()&{
& & file,&err&:=&os.Open("/usr/tmp")
& & if&err&!=&nil&{
& & & & log.Fatal(err)
& & & & return
& & fmt.Println(file)
返回的值如果我们不想使用，可以使用_进行忽略。
file,&_&:=&os.Open("/usr/tmp")
多个值返回的定义也非常简单，看个例子。
func&add(a,&b&int)&(int,&error)&{
& & return&a&+&b,&nil
函数方法声明定义的时候，采用逗号分割，因为是多个返回，还要用括号括起来。返回的值还是使用return关键字，以逗号分割，和返回声明的顺序一致。
函数方法的参数，可以是任意多个，这种我们称之为可以变参数。比如我们常用的fmt.Println()这类函数，可以接收一个可变的参数。
func&main()&{
& & fmt.Println("1","2","3")
可以变参数，可以是任意多个。我们自己也可以定义可以变参数，可变参数的定义，在类型前加上省略号...即可。
func&main()&{
& & print("1","2","3")
func&print&(a&...interface{}){
& & for&_,v:=range&a{
& & & & fmt.Print(v)
& & fmt.Println()
例子中我们自己定义了一个接受可变参数的函数，效果和fmt.Println()一样。
可变参数本质上是一个数组，所以我们像使用数组一样使用它，比如例子中的&for range循环。
本文永久更新链接地址：
相关资讯 & & &
& (02月02日)
& (12/16/:16)
& (04月08日)
& (01月13日)
& (10/12/:31)
同意评论声明
发表
尊重网上道德，遵守中华人民共和国的各项有关法律法规
承担一切因您的行为而直接或间接导致的民事或刑事法律责任
本站管理人员有权保留或删除其管辖留言中的任意内容
本站有权在网站内转载或引用您的评论
参与本评论即表明您已经阅读并接受上述条款go中方法的接收者是值或者指针有什么区别吗？
- Go语言中文网 - Golang中文社区
<meta name="author" content="polaris ">
go中方法的接收者是值或者指针有什么区别吗？
go中方法的接收者是值或者指针有什么区别吗？
参考文章：
希望解决的问题如下
假设有两个方法，一个方法的接收者是指针类型，一个方法的接收者是值类型，那么：
对于值类型的变量和指针类型的变量，这两个方法有什么区别？如果这两个方法是为了实现一个接口，那么这两个方法都可以调用吗？如果方法是嵌入到其他结构体中的，那么上面两种情况又是怎样的？
值类型的变量和指针类型的变量
先声明一个结构体：
type T struct {
Name string
func (t T) M1() {
t.Name = "name1"
func (t *T) M2() {
t.Name = "name2"
M1() 的接收者是值类型 T, M2() 的接收者是值类型 *T , 两个方法内都是改变Name值。
下面声明一个 T 类型的变量，并调用 M1() 和 M2() 。
t1 := T{"t1"}
fmt.Println("M1调用前：", t1.Name)
fmt.Println("M1调用后：", t1.Name)
fmt.Println("M2调用前：", t1.Name)
fmt.Println("M2调用后：", t1.Name)
输出结果为：
M1调用前： t1
M1调用后： t1
M2调用前： t1
M2调用后： name2
下面猜测一下go会怎么处理。
先来约定一下：接收者可以看作是函数的第一个参数，即这样的： func M1(t T), func
M2(t *T)。 go不是面向对象的语言，所以用那种看起来像面向对象的语法来理解可能有偏差。
当调用 t1.M1() 时相当于 M1(t1) ，实参和行参都是类型
T，可以接受。此时在M1()中的t只是t1的值拷贝，所以M1()的修改影响不到t1。
当调用 t1.M2() =& M2(t1)，这是将
T 类型传给了 *T 类型，go可能会取 t1 的地址传进去： M2(&t1)。所以 M2() 的修改可以影响 t1 。
T 类型的变量这两个方法都是拥有的。
下面声明一个 *T 类型的变量，并调用 M1() 和 M2() 。
t2 := &T{"t2"}
fmt.Println("M1调用前：", t2.Name)
fmt.Println("M1调用后：", t2.Name)
fmt.Println("M2调用前：", t2.Name)
fmt.Println("M2调用后：", t2.Name)
输出结果为：
M1调用前： t2
M1调用后： t2
M2调用前： t2
M2调用后： name2
t2.M1() =& M1(t2)，
t2 是指针类型， 取 t2 的值并拷贝一份传给 M1。
t2.M2() =& M2(t2)，都是指针类型，不需要转换。
*T 类型的变量也是拥有这两个方法的。
传给接口会怎样？
先声明一个接口
type Intf interface {
var t1 T = T{"t1"}
var t2 Intf = t1
./main.go:9: cannot use t1 (type T) as type Intf in assignment:
T does not implement Intf (M2 method has pointer receiver)
var t2 Intf = t1 这一行报错。
t1 是有 M2() 方法的，但是为什么传给 t2 时传不过去呢？
t1 是值类型，赋值给 t2 时是复制值而不是指针，假设 t1 可以赋值给 t2， t2.M2() 修改 Name 的值时也是修改的拷贝的变量，无法影响到 t1，那把 t1 赋值给 t2 还有什么意义呢？所以这种赋值是不被允许的。
当把 var t2 Intf = t1 修改为 var
t2 Intf = &t1 时编译通过，此时 t2 获得的是 t1 的地址， t2.M2() 的修改可以影响到 t1 了。
如果声明一个方法 func f(t Intf) , 参数的传递和上面的直接赋值是一样的情况。
声明一个类型 S，将 T 嵌入进去
type S struct {
使用下面的例子测试一下：
t1 := T{"t1"}
s := S{t1}
fmt.Println("M1调用前：", s.Name)
fmt.Println("M1调用后：", s.Name)
fmt.Println("M2调用前：", s.Name)
fmt.Println("M2调用后：", s.Name)
fmt.Println(t1.Name)
M1调用前： t1
M1调用后： t1
M2调用前： t1
M2调用后： name2
将 T 嵌入 S， 那么 T 拥有的方法和属性 S 也是拥有的，但是接收者却不是 S 而是 T。
所以 s.M1() 相当于 M1(t1) 而不是 M1(s)。
最后 t1 的值没有改变，因为我们嵌入的是 T 类型，所以 S{t1} 的时候是将 t1 拷贝了一份。
假如我们将 s 赋值给 Intf 接口会怎么样呢？
var intf Intf = s
cannot use s (type S) as type Intf in assignment:
S does not implement Intf (M2 method has pointer receiver)
还是 M2() 的问题，因为 s 此时还是值类型。
var intf Intf = &s 这样的话编译通过了，如果在 intf.M2() 中改变了
Name 的值， s.Name 被改变了，但是t1.Name 依然没变，因为现在
t1 和 s 已经没有联系了。
下面嵌入 *T 试试：
type S struct {
使用时这样：
t1 := T{"t1"}
s := S{&t1}
fmt.Println("M1调用前：", s.Name)
fmt.Println("M1调用后：", s.Name)
fmt.Println("M2调用前：", s.Name)
fmt.Println("M2调用后：", s.Name)
fmt.Println(t1.Name)
惟一的区别是最后 t1 的值变了，因为我们复制的是指针。
接着赋值给接口试试：
var intf Intf = s
fmt.Println(s.Name)
编译没有报错。这里我们传递给 intf 的是值类型而不是指针，为什么可以通过呢？
拷贝 s 的时候里面的 T 是指针类型，所以调用 M2() 的时候传递进去的是一个指针。
var intf Intf = &s 的效果和上面一样。
支持 Markdown 格式, **粗体**、~~删除线~~、`单行代码`
支持 @ 本站用户；支持表情（输入 : 提示），见
参考文章：
希望解决的问题如下
假设有两个方法，一个方法的接收者是指针类型，一个方法的接收者是值类型，那么：
对于值类型的变量和指针类型的变量，这两个方法有什么区别？如果这两个方法是为了实现一个接口，那么这两个方法都可以调用吗？如果方法是嵌入到其他结构体中的，那么上面两种情况又是怎样的？
值类型的变量和指针类型的变量
先声明一个结构体：
type T struct {
Name string
func (t T) M1() {
t.Name = "name1"
func (t *T) M2() {
t.Name = "name2"
M1() 的接收者是值类型 T, M2() 的接收者是值类型 *T , 两个方法内都是改变Name值。
下面声明一个 T 类型的变量，并调用 M1() 和 M2() 。
t1 := T{"t1"}
fmt.Println("M1调用前：", t1.Name)
fmt.Println("M1调用后：", t1.Name)
fmt.Println("M2调用前：", t1.Name)
fmt.Println("M2调用后：", t1.Name)
输出结果为：
M1调用前： t1
M1调用后： t1
M2调用前： t1
M2调用后： name2
下面猜测一下go会怎么处理。
先来约定一下：接收者可以看作是函数的第一个参数，即这样的： func M1(t T), func
M2(t *T)。 go不是面向对象的语言，所以用那种看起来像面向对象的语法来理解可能有偏差。
当调用 t1.M1() 时相当于 M1(t1) ，实参和行参都是类型
T，可以接受。此时在M1()中的t只是t1的值拷贝，所以M1()的修改影响不到t1。
当调用 t1.M2() =& M2(t1)，这是将
T 类型传给了 *T 类型，go可能会取 t1 的地址传进去： M2(&t1)。所以 M2() 的修改可以影响 t1 。
T 类型的变量这两个方法都是拥有的。
下面声明一个 *T 类型的变量，并调用 M1() 和 M2() 。
t2 := &T{"t2"}
fmt.Println("M1调用前：", t2.Name)
fmt.Println("M1调用后：", t2.Name)
fmt.Println("M2调用前：", t2.Name)
fmt.Println("M2调用后：", t2.Name)
输出结果为：
M1调用前： t2
M1调用后： t2
M2调用前： t2
M2调用后： name2
t2.M1() =& M1(t2)，
t2 是指针类型， 取 t2 的值并拷贝一份传给 M1。
t2.M2() =& M2(t2)，都是指针类型，不需要转换。
*T 类型的变量也是拥有这两个方法的。
传给接口会怎样？
先声明一个接口
type Intf interface {
var t1 T = T{"t1"}
var t2 Intf = t1
./main.go:9: cannot use t1 (type T) as type Intf in assignment:
T does not implement Intf (M2 method has pointer receiver)
var t2 Intf = t1 这一行报错。
t1 是有 M2() 方法的，但是为什么传给 t2 时传不过去呢？
t1 是值类型，赋值给 t2 时是复制值而不是指针，假设 t1 可以赋值给 t2， t2.M2() 修改 Name 的值时也是修改的拷贝的变量，无法影响到 t1，那把 t1 赋值给 t2 还有什么意义呢？所以这种赋值是不被允许的。
当把 var t2 Intf = t1 修改为 var
t2 Intf = &t1 时编译通过，此时 t2 获得的是 t1 的地址， t2.M2() 的修改可以影响到 t1 了。
如果声明一个方法 func f(t Intf) , 参数的传递和上面的直接赋值是一样的情况。
声明一个类型 S，将 T 嵌入进去
type S struct {
使用下面的例子测试一下：
t1 := T{"t1"}
s := S{t1}
fmt.Println("M1调用前：", s.Name)
fmt.Println("M1调用后：", s.Name)
fmt.Println("M2调用前：", s.Name)
fmt.Println("M2调用后：", s.Name)
fmt.Println(t1.Name)
M1调用前： t1
M1调用后： t1
M2调用前： t1
M2调用后： name2
将 T 嵌入 S， 那么 T 拥有的方法和属性 S 也是拥有的，但是接收者却不是 S 而是 T。
所以 s.M1() 相当于 M1(t1) 而不是 M1(s)。
最后 t1 的值没有改变，因为我们嵌入的是 T 类型，所以 S{t1} 的时候是将 t1 拷贝了一份。
假如我们将 s 赋值给 Intf 接口会怎么样呢？
var intf Intf = s
cannot use s (type S) as type Intf in assignment:
S does not implement Intf (M2 method has pointer receiver)
还是 M2() 的问题，因为 s 此时还是值类型。
var intf Intf = &s 这样的话编译通过了，如果在 intf.M2() 中改变了
Name 的值， s.Name 被改变了，但是t1.Name 依然没变，因为现在
t1 和 s 已经没有联系了。
下面嵌入 *T 试试：
type S struct {
使用时这样：
t1 := T{"t1"}
s := S{&t1}
fmt.Println("M1调用前：", s.Name)
fmt.Println("M1调用后：", s.Name)
fmt.Println("M2调用前：", s.Name)
fmt.Println("M2调用后：", s.Name)
fmt.Println(t1.Name)
惟一的区别是最后 t1 的值变了，因为我们复制的是指针。
接着赋值给接口试试：
var intf Intf = s
fmt.Println(s.Name)
编译没有报错。这里我们传递给 intf 的是值类型而不是指针，为什么可以通过呢？
拷贝 s 的时候里面的 T 是指针类型，所以调用 M2() 的时候传递进去的是一个指针。
var intf Intf = &s 的效果和上面一样。
记住登录状态
还不是会员
