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 的效果和上面一样。

总结

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

(0)

相关推荐

  • golang方法中receiver为指针与不为指针的区别详析

    前言 golang的指针receiver和非指针receiver的区别?最近在看网站有同学提问golang中方法的receiver为指针和不为指针有什么区别,在这里我以简单易懂的方法进行说明,帮助刚刚学习golang的同学,下面话不多说了,来一起看看详细的介绍吧. 方法是什么 其实只要明白这个原理,基本就能理解上面提到的问题. 方法其实就是一种特殊的函数,receiver就是隐式传入的第一实参. 举个例子 type test struct{ name string } func (t test)

  • 关于Golang中range指针数据的坑详解

    前言 在Golang中使用 for range 语句进行迭代非常的便捷,但在涉及到指针时就得小心一点了. 下面的代码中定义了一个元素类型为 *int 的通道 ch : package main import ( "fmt" ) func main() { ch := make(chan *int, 5) //sender input := []int{1,2,3,4,5} go func(){ for _, v := range input { ch <- &v } cl

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

    前言 值类型:所有像int.float.bool和string这些类型都属于值类型,使用这些类型的变量直接指向存在内存中的值,值类型的变量的值存储在栈中.当使用等号=将一个变量的值赋给另一个变量时,如 j = i ,实际上是在内存中将 i 的值进行了拷贝.可以通过 &i 获取变量 i 的内存地址 指针类型:简单地说go语言的指针类型和C/C++的指针类型用法是一样的,除了出去安全性的考虑,go语言增加了一些限制,包括如下几条: 不同类型的指针不能互相转化,例如*int, int32, 以及int

  • golang 中string和int类型相互转换

    总结了golang中字符串和各种int类型之间的相互转换方式: string转成int: int, err := strconv.Atoi(string) string转成int64: int64, err := strconv.ParseInt(string, 10, 64) int转成string: string := strconv.Itoa(int) int64转成string: string := strconv.FormatInt(int64,10) 字符串到float32/floa

  • Java中值传递和引用传递的区别

    在Java中参数的传递主要有两种:值传递和参数传递: 下面是对两种传递方式在内存上的分析: 一:值传递 解释:实参传递给形参的是值  形参和实参在内存上是两个独立的变量 对形参做任何修改不会影响实参 代码示例如下: package arrayDemo; public class Demo1 { public static void main(String[] args) { int b =20; change(b);// 实参 实际上的参数 System.out.println(b); } pu

  • Golang中的time.Duration类型用法说明

    在 Time 包中,定义有一个名为 Duration 的类型和一些辅助的常量: type Duration int64 const ( Nanosecond Duration = 1 Microsecond = 1000 * Nanosecond Millisecond = 1000 * Microsecond Second = 1000 * Millisecond Minute = 60 * Second Hour = 60 * Minute ) 那么我们看下面一段代码: func Test(

  • Go语言-为什么返回值为接口类型,却返回结构体

    最近由于项目需求,阅读一些Go语言编写的项目的源代码,在某一个函数中发现了一个奇怪的现象:一个函数的返回值类型声明的是一个接口的类型,但是实际在函数体内返回的却是一个结构体类型的对象. 这个现象对于新手的我来说很是费解.在经过一些资料的查阅之后,自己得到了如下的解释: 一个结构体实现了一个接口,那么函数中返回值类型为接口时,就应该返回这个结构体. 下面举一个例子来说明: package main import ( "fmt" ) /** Shape接口定义两个函数: area() :计

  • C语言中传值与传指针的介绍与区别

    前言 我们可能听过C语言中的传值和传指针,在其他语言中,也有传引用一说,那么他们到底有什么区别呢?如果你还不能准确地分辨,就该好好了解一下了. 传值 我们在初学C语言的时候就被老师教过,下面的方式是无法交换a和b的值的: #include<stdio.h> void swap(int a,int b) { int temp = a; a = b; b = temp; printf("swap a = %d,b = %d\n",a,b); } int main(void) {

  • golang中struct和[]byte的相互转换示例

    在网络传输过程中,经常会这样处理:socket接收到数据,先获取其消息头,然后再做各种不同的业务处理.在解析消息头的时候的方法有多种多样.其中最为高效解析消息头的方法就是直接把数据头部分强制类型转换为对应的消息头结构体.这种做法在C/C++中非常的常见.而golang其实也是可以这样子做的.类似这样的应用,直接类型转换获取消息对应的解析方法其实效率会相对较高. golang中struct和[]byte的转换方法,其实就是用到了golang中的unsafe包加上类型转换 , 约束:struct中不

  • golang中的单引号转义问题

    目录 golang的单引号转义 go语言中的单引号.双引号和反引号 1.单引号 2.双引号 3.反引号 总结 golang的单引号转义 如题,golang中有时候需要将一个字符串中的单引号再转义一次,比如在两个单引号之间包含一个含有单引号的字符串的情形. 但是这个转义却不像C语言里的那样,比如这样写:info = strings.Replace(info, "\'", "\\\'", -1) 就报unknown escape sequence错误. 正确的写法是:

  • go语言中值类型和指针类型的深入理解

    golang这个语言用起来和java. c#之类语言差不多,和c/c++差别比较大,有自动管理内存机制,省心省力. 然而,如果写golang真的按写java的习惯去写,也容易出问题,因为golang中有指针的概念,虽然这个指针是c/c++的自动化版本,但是却也有指针的特征,如果不熟悉其中原理,写出来的程序虽然不至于有运行BUG,性能却不友好. 因此,不能完全以写java的思路去写golang,一定要注意其中差别. 我们知道,在java之中,除了基本类型之外,所有的变量类型都是引用类型,你可以随意

  • 详解为什么说Golang中的字符串类型不能修改

    目录 字符串定义 字符串的组成 字符串不能修改 字符串的赋值 为什么这么设计 在接触Go这么语言,可能你经常会听到这样一句话.对于字符串不能修改,可能你很纳闷,日常开发中我们对字符串进行修改也是很正常的,为什么又说Go中的字符串不能进行修改呢? 本文就来通过实际案例给大家演示,为什么Go中的字符串不能进行修改. 在演示这个问题之前,我们先对字符串类型的基础知识做个大致的演示,这样便于大家对问题的进一步了解. 字符串定义 字符串是一种用来表示字符的数据类型.在使用时,使用" "将字符内容

随机推荐