golang에는 포인터가 있습니다. Go 언어의 포인터 지원은 Java 언어와 C/C++ 언어 사이에 있습니다. 이는 Java처럼 포인터를 직접 작동하는 코드의 기능을 취소하지도 않고 C/C++에서 포인터의 남용을 방지하지도 않습니다.
이 튜토리얼의 운영 환경: windows10 시스템, GO 1.11.2, thinkpad t480 컴퓨터.
포인터는 특정 메모리 주소를 나타내는 값입니다. 이 메모리 주소는 종종 메모리에 저장된 다른 변수 값의 시작 위치입니다.
포인터 주소와 변수 공간
Go 언어는 포인터를 유지하지만 C 언어 포인터와는 다릅니다. 주로 반영되는 항목:
기본값: nil
operator
& code> 변수 주소를 취하고 <code>*
는 포인터를 통해 대상 개체에 액세스합니다.&
取变量地址,*
通过指针访问目标对象。不支持指针运算,不支持
->
运算符,直接用.
访问目标成员。
先来看一段代码:
package main import "fmt" func main(){ var x int = 99 var p *int = &x fmt.Println(p) }
当我们运行到 var x int = 99
时,在内存中就会生成一个空间,这个空间我们给它起了个名字叫 x
,同时, 它也有一个地址,例如: 0xc00000a0c8
,当我们想要使用这个空间时,我们可以用地址去访问,也可以用我们给它起的名字 x
去访问.
继续运行到 var p *int = &x
时,我们定义了一个指针变量 p
,这个 p
就存储了变量 x
的地址.
所以,指针就是地址,指针变量就是存储地址的变量。
接着,我们更改 x
的内容:
package main import "fmt" func main() { var x int = 99 var p *int = &x fmt.Println(p) x = 100 fmt.Println("x: ", x) fmt.Println("*p: ", *p) *p = 999 fmt.Println("x: ", x) fmt.Println("*p: ", *p) }
可以发现, x
与 *p
的结果一样的。
其中, *p
称为 解引用
或者 间接引用
。
*p = 999
是通过借助 x
变量的地址,来操作 x
对应的空间。
不管是 x
还是 *p
, 我们操作的都是同一个空间。
栈帧的内存布局
首先, 先来看一下内存布局图, 以 32位
为例.
其中, 数据区保存的是初始化后的数据.
上面的代码都存储在栈区. 一般 make()
或者 new()
出来的都存储在堆区
接下来, 我们来了解一个新的概念: 栈帧.
栈帧: 用来给函数运行提供内存空间, 取内存于 stack
上.
当函数调用时, 产生栈帧; 函数调用结束, 释放栈帧.
那么栈帧用来存放什么?
- 局部变量
- 形参
- 内存字段描述值
其中, 形参与局部变量存储地位等同
当我们的程序运行时, 首先运行 main()
, 这时就产生了一个栈帧.
当运行到 var x int = 99
时, 就会在栈帧里面产生一个空间.
同理, 运行到 var p *int = &x
时也会在栈帧里产生一个空间.
如下图所示:
我们增加一个函数, 再来研究一下.
package mainimport "fmt"func test(m int){ var y int = 66 y += m}func main() { var x int = 99 var p *int = &x fmt.Println(p) x = 100 fmt.Println("x: ", x) fmt.Println("*p: ", *p) test(11) *p = 999 fmt.Println("x: ", x) fmt.Println("*p: ", *p)}
如下图所示, 当运行到 test(11)
时, 会继续产生一个栈帧, 这时 main()
产生的栈帧还没有结束.
当 test()
运行完毕时, 就会释放掉这个栈帧.
空指针与野指针
空指针: 未被初始化的指针.
var p *int
这时如果我们想要对其取值操作 *p
, 会报错.
野指针: 被一片无效的地址空间初始化.
var p *int = 0xc00000a0c8
指针变量的内存存储
表达式 new(T)
将创建一个 T
类型的匿名变量, 所做的是为 T
类型的新值分配并清零一块内存空间, 然后将这块内存空间的地址作为结果返回, 而这个结果就是指向这个新的 T
类型值的指针值, 返回的指针类型为 *T
->
연산자를 지원하지 않습니다. .
를 직접 사용하여 대상 멤버에 액세스합니다. 🎜🎜🎜먼저 코드를 살펴보겠습니다: 🎜package mainimport "fmt"func main(){ p := new(int) fmt.Println(p) fmt.Println(*p)}🎜
var x int = 99
로 실행하면 메모리에 공백이 생성되며 이를 지정했습니다. 공백 이름은 x
이고 주소도 있습니다(예: 0xc00000a0c8
). 이 공백을 사용하려면 🎜address🎜를 사용하여 액세스할 수 있습니다. 또는 우리가 액세스하기 위해 제공한 🎜name🎜 x
을 사용할 수 있습니다. 🎜🎜 var p *int = &x
를 계속 실행하면 🎜를 정의합니다. 포인터 변수🎜 p
, 이 p
는 변수 x
의 주소를 저장합니다. 🎜🎜그래서 🎜포인터는 주소이고 포인터 변수는 주소를 저장하는 변수입니다. 🎜🎜🎜다음으로 x
의 내용을 변경합니다.🎜package mainimport "fmt"func main(){ p := new(int) *p = 1000 fmt.Println(p) fmt.Println(*p)}🎜
x
와 *p
의 결과가 동일한 것을 확인할 수 있습니다 . 🎜🎜그 중 *p
를 역참조
또는 간접 참조
라고 합니다. 🎜🎜*p = 999
는 x
변수의 주소를 사용하여 x
에 해당하는 공간을 연산합니다. 🎜🎜🎜 🎜 x
🎜이든 🎜 *p
🎜이든 같은 공간에서 운영하고 있습니다. 🎜🎜🎜🎜스택 프레임의 메모리 레이아웃🎜🎜🎜먼저 32비트
를 예로 들어 메모리 레이아웃 다이어그램을 살펴보겠습니다.🎜🎜
make()
또는 new()
의 출력은 에 저장됩니다. 힙 영역🎜🎜 다음으로 새로운 개념에 대해 알아보겠습니다: 🎜스택 프레임🎜.🎜🎜스택 프레임: 🎜function🎜이 실행될 메모리 공간을 제공하고 스택.🎜🎜🎜함수가 호출되면 스택 프레임이 생성되고, 함수 호출이 끝나면 스택 프레임이 해제됩니다.🎜🎜🎜그럼 저장하는 데 사용되는 스택 프레임은 무엇인가요?🎜<ul>🎜 🎜로컬 변수🎜🎜🎜🎜형식 매개변수🎜🎜🎜메모리 필드 설명 값🎜</ul>🎜그 중 🎜로컬 변수 저장 상태에 대한 형태의 참여는 동일합니다🎜🎜🎜저희 프로그램이 실행되면 먼저 <code>main()
, 스택 프레임이 생성됩니다.🎜🎜var x int = 99로 실행하면 스택 프레임에 공백이 생성됩니다. 🎜🎜마찬가지로, var p *int = &x
로 실행하면 스택 프레임에도 있게 됩니다. 공백을 생성합니다.🎜🎜아래와 같이:🎜🎜
var x int = 10var y int = 20x = y🎜그림과 같이 아래에서는
test(11)
를 실행하면 스택 프레임이 계속 생성되는데, 이때 main()
에 의해 생성된 스택 프레임은 아직 끝나지 않았습니다. 🎜🎜
test()
실행이 완료되면 이 스택 프레임이 해제됩니다.🎜🎜
p := new(int)*p = 1000fmt.Println(*p)🎜이때 * p 값에 대해 오류가 보고됩니다.🎜🎜🎜와일드 포인터🎜: 잘못된 주소 공간으로 초기화되었습니다. 🎜
func foo() { p := new(int) *p = 1000}🎜포인터 변수의 메모리 저장🎜🎜
new(T) 표현식 code>는 <code>T
유형의 익명 변수를 생성합니다. 그 역할은 T
입니다. code> 유형의 새 값에 대한 메모리 공간을 할당하고 지운 다음 주소를 반환합니다. 이 메모리 공간의 결과는 T
유형의 새 값을 가리키는 포인터 값입니다. 반환 포인터 유형은 *T
입니다.🎜new()
创建的内存空间位于heap上, 空间的默认值为数据类型的默认值. 如: p := new(int)
则 *p
为 0
.
package mainimport "fmt"func main(){ p := new(int) fmt.Println(p) fmt.Println(*p)}
这时 p
就不再是空指针或者野指针.
我们只需使用 new()
函数, 无需担心其内存的生命周期或者怎样将其删除, 因为Go语言的内存管理系统会帮我们打理一切.
接着我们改一下*p
的值:
package mainimport "fmt"func main(){ p := new(int) *p = 1000 fmt.Println(p) fmt.Println(*p)}
这个时候注意了, *p = 1000
中的 *p
与 fmt.Println(*p)
中的 *p
是一样的吗?
大家先思考一下, 然后先来看一个简单的例子:
var x int = 10var y int = 20x = y
好, 大家思考一下上面代码中, var y int = 20
中的 y
与 x = y
中的 y
一样不一样?
结论: 不一样
var y int = 20
中的 y
代表的是内存空间, 我们一般把这样的称之为左值; 而 x = y
中的 y
代表的是内存空间中的内容, 我们一般称之为右值.
x = y
表示的是把 y
对应的内存空间的内容写到x内存空间中.
等号左边的变量代表变量所指向的内存空间, 相当于写操作.
等号右边的变量代表变量内存空间存储的数据值, 相当于读操作.
在了解了这个之后, 我们再来看一下之前的代码.
p := new(int)*p = 1000fmt.Println(*p)
所以, *p = 1000
的意思是把1000写到 *p
的内存中去;
fmt.Println(*p)
是把 *p
的内存空间中存储的数据值打印出来.
所以这两者是不一样的.
如果我们不在main()创建会怎样?
func foo() { p := new(int) *p = 1000}
我们上面已经说过了, 当运行 foo()
时会产生一个栈帧, 运行结束, 释放栈帧.
那么这个时候, p
还在不在?
p
在哪? 栈帧是在栈上, 而 p
因为是 new()
生成的, 所以在 堆
上. 所以, p
没有消失, p
对应的内存值也没有消失, 所以利用这个我们可以实现传地址.
对于堆区, 我们通常认为它是无限的. 但是无限的前提是必须申请完使用, 使用完后立即释放.
函数的传参
明白了上面的内容, 我们再去了解指针作为函数参数就会容易很多.
传地址(引用): 将地址值作为函数参数传递.
传值(数据): 将实参的值拷贝一份给形参.
无论是传地址还是传值, 都是实参将自己的值拷贝一份给形参.只不过这个值有可能是地址, 有可能是数据.
所以, 函数传参永远都是值传递.
了解了概念之后, 我们来看一个经典的例子:
package mainimport "fmt"func swap(x, y int){ x, y = y, x fmt.Println("swap x: ", x, "y: ", y)}func main(){ x, y := 10, 20 swap(x, y) fmt.Println("main x: ", x, "y: ", y)}
结果:
swap x: 20 y: 10main x: 10 y: 20
我们先来简单分析一下为什么不一样.
首先当运行 main()
时, 系统在栈区产生一个栈帧, 该栈帧里有 x
和 y
两个变量.
当运行 swap()
时, 系统在栈区产生一个栈帧, 该栈帧里面有 x
和 y
两个变量.
运行 x, y = y, x
后, 交换 swap()
产生的栈帧里的 xy
值. 这时 main()
里的 xy
没有变.
swap()
运行完毕后, 对应的栈帧释放, 栈帧里的x
y
值也随之消失.
所以, 当运行 fmt.Println("main x: ", x, "y: ", y)
这句话时, 其值依然没有变.
接下来我们看一下参数为地址值时的情况.
传地址的核心思想是: 在自己的栈帧空间中修改其它栈帧空间中的值.
而传值的思想是: 在自己的栈帧空间中修改自己栈帧空间中的值.
注意理解其中的差别.
继续看以下这段代码:
package mainimport "fmt"func swap2(a, b *int){ *a, *b = *b, *a}func main(){ x, y := 10, 20 swap(x, y) fmt.Println("main x: ", x, "y: ", y)}
结果:
main x: 20 y: 10
这里并没有违反 函数传参永远都是值传递
这句话, 只不过这个时候这个值为地址值.
这个时候, x
与 y
的值就完成了交换.
我们来分析一下这个过程.
首先运行 main()
后创建一个栈帧, 里面有 x
y
两个变量.
运行 swap2()
时, 同样创建一个栈帧, 里面有 a
b
两个变量.
이때 a
a
和 b
中存储的值是 x
和 y
的地址.
当运行到 *a, *b = *b, *a
时, 左边的 *a
代表的是 x
的内存地址, 右边的 *b
代表的是 y
的内存地址中的内容. 所以这个时候, main()
中的 x
就被替换掉了.
所以, 这是在 swap2()
中操作 main()
里的变量值.
现在 swap2()
再释放也没有关系了, 因为 main()
및
b
에 저장된 값은 x
및
y
🎜.🎜🎜🎜의 주소 *a, *b = *b, *a
로 실행하면 왼쪽의 *a
는 x
의 메모리 주소, 오른쪽의 *b
는 y
의 메모리 주소 내용을 나타냅니다. >main() 🎜🎜그래서 🎜이 작업은 🎜 swap2()
🎜 main()에서 수행됩니다. code> 🎜.🎜🎜🎜의 변수 값 이제 <code>main()
의 값이 변경되었으므로 swap2()
가 다시 해제되어도 상관이 없습니다. 🎜🎜추천 학습: 🎜Golang Tutorial🎜🎜위 내용은 golang에는 포인터가 있습니까?의 상세 내용입니다. 자세한 내용은 PHP 중국어 웹사이트의 기타 관련 기사를 참조하세요!

go语言有缩进。在go语言中,缩进直接使用gofmt工具格式化即可(gofmt使用tab进行缩进);gofmt工具会以标准样式的缩进和垂直对齐方式对源代码进行格式化,甚至必要情况下注释也会重新格式化。

本篇文章带大家了解一下golang 的几种常用的基本数据类型,如整型,浮点型,字符,字符串,布尔型等,并介绍了一些常用的类型转换操作。

go语言叫go的原因:想表达这门语言的运行速度、开发速度、学习速度(develop)都像gopher一样快。gopher是一种生活在加拿大的小动物,go的吉祥物就是这个小动物,它的中文名叫做囊地鼠,它们最大的特点就是挖洞速度特别快,当然可能不止是挖洞啦。

是,TiDB采用go语言编写。TiDB是一个分布式NewSQL数据库;它支持水平弹性扩展、ACID事务、标准SQL、MySQL语法和MySQL协议,具有数据强一致的高可用特性。TiDB架构中的PD储存了集群的元信息,如key在哪个TiKV节点;PD还负责集群的负载均衡以及数据分片等。PD通过内嵌etcd来支持数据分布和容错;PD采用go语言编写。

在写 Go 的过程中经常对比这两种语言的特性,踩了不少坑,也发现了不少有意思的地方,下面本篇就来聊聊 Go 自带的 HttpClient 的超时机制,希望对大家有所帮助。

go语言需要编译。Go语言是编译型的静态语言,是一门需要编译才能运行的编程语言,也就说Go语言程序在运行之前需要通过编译器生成二进制机器码(二进制的可执行文件),随后二进制文件才能在目标机器上运行。

删除map元素的两种方法:1、使用delete()函数从map中删除指定键值对,语法“delete(map, 键名)”;2、重新创建一个新的map对象,可以清空map中的所有元素,语法“var mapname map[keytype]valuetype”。


핫 AI 도구

Undresser.AI Undress
사실적인 누드 사진을 만들기 위한 AI 기반 앱

AI Clothes Remover
사진에서 옷을 제거하는 온라인 AI 도구입니다.

Undress AI Tool
무료로 이미지를 벗다

Clothoff.io
AI 옷 제거제

AI Hentai Generator
AI Hentai를 무료로 생성하십시오.

인기 기사

뜨거운 도구

안전한 시험 브라우저
안전한 시험 브라우저는 온라인 시험을 안전하게 치르기 위한 보안 브라우저 환경입니다. 이 소프트웨어는 모든 컴퓨터를 안전한 워크스테이션으로 바꿔줍니다. 이는 모든 유틸리티에 대한 액세스를 제어하고 학생들이 승인되지 않은 리소스를 사용하는 것을 방지합니다.

DVWA
DVWA(Damn Vulnerable Web App)는 매우 취약한 PHP/MySQL 웹 애플리케이션입니다. 주요 목표는 보안 전문가가 법적 환경에서 자신의 기술과 도구를 테스트하고, 웹 개발자가 웹 응용 프로그램 보안 프로세스를 더 잘 이해할 수 있도록 돕고, 교사/학생이 교실 환경 웹 응용 프로그램에서 가르치고 배울 수 있도록 돕는 것입니다. 보안. DVWA의 목표는 다양한 난이도의 간단하고 간단한 인터페이스를 통해 가장 일반적인 웹 취약점 중 일부를 연습하는 것입니다. 이 소프트웨어는

SublimeText3 영어 버전
권장 사항: Win 버전, 코드 프롬프트 지원!

에디트플러스 중국어 크랙 버전
작은 크기, 구문 강조, 코드 프롬프트 기능을 지원하지 않음

SublimeText3 Linux 새 버전
SublimeText3 Linux 최신 버전
