golang中值类型/指针类型的变量区别总结

前言

值类型：所有像int、float、bool和string这些类型都属于值类型，使用这些类型的变量直接指向存在内存中的值，值类型的变量的值存储在栈中。当使用等号=将一个变量的值赋给另一个变量时，如 j = i ,实际上是在内存中将 i 的值进行了拷贝。可以通过 &i 获取变量 i 的内存地址

指针类型：简单地说go语言的指针类型和c/c++的指针类型用法是一样的，除了出去安全性的考虑，go语言增加了一些限制，包括如下几条：

• 不同类型的指针不能互相转化，例如*int, int32, 以及int64
• 任何普通指针类型*t和uintptr之间不能互相转化
• 指针变量不能进行运算, 比如c/c++里面的++, --运算

下面将给大家详细介绍golang中值类型/指针类型的变量的一些区别，下面话不多说了，来一起看看详细的介绍吧。

值类型的变量和指针类型的变量

先声明一个结构体：

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)
 t1.m1()
 fmt.println("m1调用后：", t1.name)
 fmt.println("m2调用前：", t1.name)
 t1.m2()
 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 类型的变量，并调用 m1() 和 m2() 。

 t2 := &t{"t2"}
 fmt.println("m1调用前：", t2.name)
 t2.m1()
 fmt.println("m1调用后：", t2.name)
 fmt.println("m2调用前：", t2.name)
 t2.m2()
 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 {
 m1()
 m2()
}

使用：

 var t1 t = t{"t1"}
 t1.m1()
 t1.m2()
 var t2 intf = t1
 t2.m1()
 t2.m2()

报错：

./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没有实现m2() ，t1的指针实现了m2() 。另外和c语言一样，函数名本身就是指针

当把 var t2 intf = t1 修改为 var t2 intf = &t1 时编译通过，此时 t2 获得的是 t1 的地址， t2.m2() 的修改可以影响到 t1 了。

如果声明一个方法 func f(t intf) , 参数的传递和上面的直接赋值是一样的情况。

嵌套类型

声明一个类型 s，将 t 嵌入进去

type s struct { t }

使用下面的例子测试一下：

 t1 := t{"t1"} 
 s := s{t1} 
 fmt.println("m1调用前：", s.name) 
 s.m1() 
 fmt.println("m1调用后：", s.name) 
 fmt.println("m2调用前：", s.name) 
 s.m2() 
 fmt.println("m2调用后：", s.name) 
 fmt.println(t1.name)

输出：

m1调用前： t1

m1调用后： t1

m2调用前： t1

m2调用后： name2

t1

将 t 嵌入 s， 那么 t 拥有的方法和属性 s 也是拥有的，但是接收者却不是 s 而是 t。

所以 s.m1() 相当于 m1(t1) 而不是 m1(s) 。

最后 t1 的值没有改变，因为我们嵌入的是 t 类型，所以 s{t1} 的时候是将 t1 拷贝了一份。

假如我们将 s 赋值给 intf 接口会怎么样呢？

 var intf intf = s 
 intf.m1() 
 intf.m2()

报错：

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 { *t }

使用时这样：

 t1 := t{"t1"} 
 s := s{&t1} 
 fmt.println("m1调用前：", s.name) 
 s.m1() 
 fmt.println("m1调用后：", s.name) 
 fmt.println("m2调用前：", s.name) 
 s.m2() 
 fmt.println("m2调用后：", s.name) 
 fmt.println(t1.name)

m1调用前： t1

m1调用后： t1

m2调用前： t1

m2调用后： name2

name2

惟一的区别是最后 t1 的值变了，因为我们复制的是指针。

接着赋值给接口试试：

 var intf intf = s i
 ntf.m1() 
 intf.m2() 
 fmt.println(s.name)

编译没有报错。这里我们传递给 intf 的是值类型而不是指针，为什么可以通过呢？

拷贝 s 的时候里面的 t 是指针类型，所以调用 m2() 的时候传递进去的是一个指针。

var intf intf = &s 的效果和上面一样。

总结

以上就是这篇文章的全部内容了，希望本文的内容对大家的学习或者工作具有一定的参考学习价值，如果有疑问大家可以留言交流，谢谢大家对的支持。