备案控制台
探索云世界
开发者社区 开发与运维 文章 正文

100天精通Golang（基础入门篇）——第17天：深入解析Go语言中的指针

2023-10-12 33
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
简介： 100天精通Golang（基础入门篇）——第17天：深入解析Go语言中的指针

🌷 博主 libin9iOak带您 Go to Golang Language.✨

🦄 个人主页——libin9iOak的博客🎐
🐳 《面试题大全》 文章图文并茂🦕生动形象🦖简单易学！欢迎大家来踩踩~🌺
🌊 《IDEA开发秘籍》学会IDEA常用操作，工作效率翻倍~💐
🪁 希望本文能够给您带来一定的帮助🌸文章粗浅，敬请批评指正！🐥



100天精通Golang（基础入门篇）——第17天：深入解析Go语言中的指针

摘要:

本篇文章主要深入解析Go语言中的指针，从指针的概念、获取变量地址，声明指针，空指针，获取指针的值，操作指针改变变量的数值，使用指针传递函数的参数，以及指针的指针等方面进行讲解和示例演示。

引言:

指针是Go语言中一种重要的概念，它提供了直接访问内存地址的能力，使得我们可以更灵活地操作数据和进行内存管理。在本篇文章中，我们将深入探讨指针的各个方面，并通过实际的代码案例来加深对指针的理解和应用。

前言:

在Go语言中，变量在内存中存储，而指针则指向这些内存地址。通过指针，我们可以通过内存地址直接访问和修改变量的值，这为Go语言提供了更高的性能和灵活性。本篇文章将带领读者逐步了解指针的概念和用法，帮助读者在日常的Go编程中更加熟练地使用指针。

一、指针

1.1 指针的概念

指针是存储另一个变量的内存地址的变量。

我们都知道，变量是一种使用方便的占位符，用于引用计算机内存地址。

一个指针变量可以指向任何一个值的内存地址它指向那个值的内存地址。

在上面的图中，变量b的值为156，存储在内存地址0x1040a124。变量a持有b的地址，现在a被认为指向b。

1.2 获取变量的地址

Go 语言的取地址符是 &，放到一个变量前使用就会返回相应变量的内存地址。

package main
import "fmt"
func main() {
   var a int = 10   
   fmt.Printf("变量的地址: %x\n", &a  )
}

运行结果：

变量的地址: 20818a220

1.3 声明指针

声明指针，*T是指针变量的类型，它指向T类型的值。

var var_name *var-type

var-type 为指针类型，var_name 为指针变量名，* 号用于指定变量是作为一个指针。

var ip *int        /* 指向整型*/
var fp *float32    /* 指向浮点型 */

示例代码：

package main
import "fmt"
func main() {
   var a int= 20   /* 声明实际变量 */
   var ip *int        /* 声明指针变量 */
   ip = &a  /* 指针变量的存储地址 */
   fmt.Printf("a 变量的地址是: %x\n", &a  )
   /* 指针变量的存储地址 */
   fmt.Printf("ip 变量的存储地址: %x\n", ip )
   /* 使用指针访问值 */
   fmt.Printf("*ip 变量的值: %d\n", *ip )
}

运行结果：

a 变量的地址是: 20818a220
ip 变量的存储地址: 20818a220
*ip 变量的值: 20

示例代码：

package main
import "fmt"
type name int8
type first struct {
  a int
  b bool
  name
}
func main() {
  a := new(first)
  a.a = 1
  a.name = 11
  fmt.Println(a.b, a.a, a.name)
}

运行结果：

false 1 11

未初始化的变量自动赋上初始值

package main
import "fmt"
type name int8
type first struct {
  a int
  b bool
  name
}
func main() {
  var a = first{1, false, 2}
  var b *first = &a
  fmt.Println(a.b, a.a, a.name, &a, b.a, &b, (*b).a)
}

运行结果：

false 1 2 &{1 false 2} 1 0xc042068018 1

获取指针地址在指针变量前加&的方式

1.4 空指针

Go 空指针

当一个指针被定义后没有分配到任何变量时，它的值为 nil。

nil 指针也称为空指针。

nil在概念上和其它语言的null、None、nil、NULL一样，都指代零值或空值。

一个指针变量通常缩写为 ptr。

空指针判断：

if(ptr != nil)     /* ptr 不是空指针 */
if(ptr == nil)    /* ptr 是空指针 */

1.5 获取指针的值

获取一个指针意味着访问指针指向的变量的值。语法是：*a

示例代码：

package main  
import (  
    "fmt"
)
func main() {  
    b := 255
    a := &b
    fmt.Println("address of b is", a)
    fmt.Println("value of b is", *a)
}

1.6 操作指针改变变量的数值

示例代码：

package main
import (  
    "fmt"
)
func main() {  
    b := 255
    a := &b
    fmt.Println("address of b is", a)
    fmt.Println("value of b is", *a)
    *a++
    fmt.Println("new value of b is", b)
}

运行结果

address of b is 0x1040a124  
value of b is 255  
new value of b is 256

1.7 使用指针传递函数的参数

示例代码

package main
import (  
    "fmt"
)
func change(val *int) {  
    *val = 55
}
func main() {  
    a := 58
    fmt.Println("value of a before function call is",a)
    b := &a
    change(b)
    fmt.Println("value of a after function call is", a)
}

运行结果

value of a before function call is 58  
value of a after function call is 55

不要将一个指向数组的指针传递给函数。使用切片。

假设我们想对函数内的数组进行一些修改，并且对调用者可以看到函数内的数组所做的更改。一种方法是将一个指向数组的指针传递给函数。

package main
import (  
    "fmt"
)
func modify(arr *[3]int) {  
    (*arr)[0] = 90
}
func main() {  
    a := [3]int{89, 90, 91}
    modify(&a)
    fmt.Println(a)
}

运行结果

[90 90 91]

示例代码：

package main
import (  
    "fmt"
)
func modify(arr *[3]int) {  
    arr[0] = 90
}
func main() {  
    a := [3]int{89, 90, 91}
    modify(&a)
    fmt.Println(a)
}

运行结果

[90 90 91]

虽然将指针传递给一个数组作为函数的参数并对其进行修改，但这并不是实现这一目标的惯用方法。我们有切片。

示例代码：

package main
import (  
    "fmt"
)
func modify(sls []int) {  
    sls[0] = 90
}
func main() {  
    a := [3]int{89, 90, 91}
    modify(a[:])
    fmt.Println(a)
}

运行结果：

[90 90 91]

Go不支持指针算法。

package main

func main() {

b := […]int{109, 110, 111}

p := &b

p++

}

nvalid operation: p++ (non-numeric type *[3]int)

指针数组

package main
import "fmt"
const MAX int = 3
func main() {
   a := []int{10,100,200}
   var i int
   for i = 0; i < MAX; i++ {
      fmt.Printf("a[%d] = %d\n", i, a[i] )
   }
}

结果

a[0] = 10
a[1] = 100
a[2] = 200

有一种情况，我们可能需要保存数组，这样我们就需要使用到指针。

package main
import "fmt"
const MAX int = 3
func main() {
   a := []int{10,100,200}
   var i int
   var ptr [MAX]*int;
   for  i = 0; i < MAX; i++ {
      ptr[i] = &a[i] /* 整数地址赋值给指针数组 */
   }
   for  i = 0; i < MAX; i++ {
      fmt.Printf("a[%d] = %d\n", i,*ptr[i] )
   }
}

结果

a[0] = 10
a[1] = 100
a[2] = 200

1.8 指针的指针

指针的指针

如果一个指针变量存放的又是另一个指针变量的地址，则称这个指针变量为指向指针的指针变量。

var ptr **int;
package main
import "fmt"
func main() {
   var a int
   var ptr *int
   var pptr **int
   a = 3000
   /* 指针 ptr 地址 */
   ptr = &a
   /* 指向指针 ptr 地址 */
   pptr = &ptr
   /* 获取 pptr 的值 */
   fmt.Printf("变量 a = %d\n", a )
   fmt.Printf("指针变量 *ptr = %d\n", *ptr )
   fmt.Printf("指向指针的指针变量 **pptr = %d\n", **pptr)
}

结果

变量 a = 3000
指针变量 *ptr = 3000
指向指针的指针变量 **pptr = 3000

指针作为函数参数

package main
import "fmt"
func main() {
   /* 定义局部变量 */
   var a int = 100
   var b int= 200
   fmt.Printf("交换前 a 的值 : %d\n", a )
   fmt.Printf("交换前 b 的值 : %d\n", b )
   /* 调用函数用于交换值
   * &a 指向 a 变量的地址
   * &b 指向 b 变量的地址
   */
   swap(&a, &b);
   fmt.Printf("交换后 a 的值 : %d\n", a )
   fmt.Printf("交换后 b 的值 : %d\n", b )
}
func swap(x *int, y *int) {
   var temp int
   temp = *x    /* 保存 x 地址的值 */
   *x = *y      /* 将 y 赋值给 x */
   *y = temp    /* 将 temp 赋值给 y */
}

结果

交换前 a 的值 : 100
交换前 b 的值 : 200
交换后 a 的值 : 200
交换后 b 的值 : 100

演示代码案例1:

package main
import "fmt"
func main() {
  /*
  指针：pointer
    存储了另一个变量的内存地址的变量。
   */
   //1.定义一个int类型的变量
   a := 10
   fmt.Println("a的数值是：",a) //10
   fmt.Printf("%T\n",a) //int
   fmt.Printf("a的地址是：%p\n",&a) //0xc00008a008
   //2.创建一个指针变量，用于存储变量a的地址
   var p1 *int
   fmt.Println(p1) //<nil>，空指针
   p1 = &a //p1指向了a的内存地址
   fmt.Println("p1的数值：",p1) //p1中存储的是a的地址
   fmt.Printf("p1自己的地址：%p\n",&p1)
   fmt.Println("p1的数值，是a的地址，该地址存储的数据：",*p1)//获取指针指向的变量的数值
   //3.操作变量，更改数值 ，并不会改变地址
   a = 100
   fmt.Println(a)
   fmt.Printf("%p\n",&a)
   //4.通过指针，改变变量的数值
   *p1 = 200
   fmt.Println(a)
   //5.指针的指针
   var p2 **int
   fmt.Println(p2)
   p2 = &p1
   fmt.Printf("%T,%T,%T\n",a,p1,p2) //int, *int, **int
   fmt.Println("p2的数值：",p2)   //p1的地址
   fmt.Printf("p2自己的地址：%p\n",&p2)
   fmt.Println("p2中存储的地址，对应的数值，就是p1的地址，对应的数据：",*p2)
   fmt.Println("p2中存储的地址，对应的数值，再获取对应的数值：",**p2)
}

运行截图:

运行结果:

GOROOT=D:\Go #gosetup
GOPATH=C:\Users\DELL\go #gosetup
D:\Go\bin\go.exe build -o C:\Users\DELL\AppData\Local\JetBrains\GoLand2023.1\tmp\GoLand\___go_build_Day17_Pointer.exe D:\GolandProjects\Day17-Pointer\demo01_pointer.go #gosetup
C:\Users\DELL\AppData\Local\JetBrains\GoLand2023.1\tmp\GoLand\___go_build_Day17_Pointer.exe
a的数值是： 10
int
a的地址是：0xc0000a6058
<nil>
p1的数值： 0xc0000a6058
p1自己的地址：0xc0000ca020
p1的数值，是a的地址，该地址存储的数据： 10
100
0xc0000a6058
200
<nil>
int,*int,**int
p2的数值： 0xc0000ca020
p2自己的地址：0xc0000ca028
p2中存储的地址，对应的数值，就是p1的地址，对应的数据： 0xc0000a6058
p2中存储的地址，对应的数值，再获取对应的数值： 200
进程 已完成，退出代码为 0

演示代码案例2:

package main
import "fmt"
func main() {
  /*
  数组指针：首先是一个指针，一个数组的地址。
    *[4]Type
  指针数组：首先是一个数组，存储的数据类型是指针
    [4]*Type
    *[5]float64,指针，一个存储了5个浮点类型数据的数组的指针
    *[3]string，指针，数组的指针，存储了3个字符串
    [3]*string，数组，存储了3个字符串的指针地址的数组
    [5]*float64，数组，存储了5个浮点数据的地址的数组
    *[5]*float64，指针，一个数组的指针，存储了5个float类型的数据的指针地址的数组的指针
    *[3]*string，指针，存储了3个字符串的指针地址的数组的指针
    **[4]string，指针，存储了4个字符串数据的数组的指针的指针
    **[4]*string，指针，存储了4个字符串的指针地址的数组，的指针的指针
   */
   //1.创建一个普通的数组
   arr1 :=[4]int{1,2,3,4}
   fmt.Println(arr1)
   //2.创建一个指针，存储该数组的地址--->数组指针
   var p1 *[4]int
   p1 = &arr1
   fmt.Println(p1) //&[1 2 3 4]
   fmt.Printf("%p\n",p1) //数组arr1的地址
   fmt.Printf("%p\n",&p1) //p1指针自己的地址
   //3.根据数组指针，操作数组
  (*p1)[0] = 100
  fmt.Println(arr1)
  p1[0] = 200 //简化写法
  fmt.Println(arr1)
  //4.指针数组
  a := 1
  b := 2
  c := 3
  d := 4
  arr2 :=[4]int{a,b,c,d}
  arr3 :=[4]*int{&a,&b,&c,&d}
  fmt.Println(arr2) //[1 2 3 4]
  fmt.Println(arr3)
  arr2[0] =100
  fmt.Println(arr2)
  fmt.Println(a)
  *arr3[0] = 200
  fmt.Println(arr3)
  fmt.Println(a)
  b = 1000
  fmt.Println(arr2)
  fmt.Println(arr3)
  for i:=0;i<len(arr3);i++{
    fmt.Println(*arr3[i])
  }
}

运行截图:

运行结果:

GOROOT=D:\Go #gosetup
GOPATH=C:\Users\DELL\go #gosetup
D:\Go\bin\go.exe build -o C:\Users\DELL\AppData\Local\JetBrains\GoLand2023.1\tmp\GoLand\___go_build_Day17_Pointer__1_.exe D:\GolandProjects\Day17-Pointer\demo02_pointerarray.go #gosetup
C:\Users\DELL\AppData\Local\JetBrains\GoLand2023.1\tmp\GoLand\___go_build_Day17_Pointer__1_.exe
[1 2 3 4]
&[1 2 3 4]
0xc000012160
0xc00000a030
[100 2 3 4]
[200 2 3 4]
[1 2 3 4]
[0xc00001e100 0xc00001e108 0xc00001e110 0xc00001e118]
[100 2 3 4]
1
[0xc00001e100 0xc00001e108 0xc00001e110 0xc00001e118]
200
[100 2 3 4]
[0xc00001e100 0xc00001e108 0xc00001e110 0xc00001e118]
200
1000
3
4
进程 已完成，退出代码为 0

演示代码案例3:

package main
import "fmt"
func main() {
  /*
    函数指针：一个指针，指向了一个函数的指针。
      因为go语言中，function，默认看作一个指针，没有*。
      slice,map,function
    指针函数：一个函数，该函数的返回值是一个指针。
  */
  var a func()
  a = fun1
  a()
  arr1 := fun2()
  fmt.Printf("arr1的类型：%T，地址：%p，数值：%v\n", arr1, &arr1, arr1)
  arr2 := fun3()
  fmt.Printf("arr2的类型：%T，地址：%p，数值：%v\n", arr2, &arr2, arr2)
  fmt.Printf("arr2指针中存储的数组的地址：%p\n", arr2)
}
func fun3() *[4]int {
  arr := [4]int{5, 6, 7, 8}
  fmt.Printf("函数中arr的地址：%p\n", &arr)
  return &arr
}
func fun2() [4]int { //普通函数
  arr := [4]int{1, 2, 3, 4}
  return arr
}
func fun1() {
  fmt.Println("fun1().....")
}

运行截图:

运行结果:

GOROOT=D:\Go #gosetup
GOPATH=C:\Users\DELL\go #gosetup
D:\Go\bin\go.exe build -o C:\Users\DELL\AppData\Local\JetBrains\GoLand2023.1\tmp\GoLand\___go_build_Day17_Pointer__2_.exe D:\GolandProjects\Day17-Pointer\demo03_pointerfunc.go #gosetup
C:\Users\DELL\AppData\Local\JetBrains\GoLand2023.1\tmp\GoLand\___go_build_Day17_Pointer__2_.exe
fun1().....
arr1的类型：[4]int，地址：0xc0000d2020，数值：[1 2 3 4]
函数中arr的地址：0xc0000d20a0
arr2的类型：*[4]int，地址：0xc0000ca020，数值：&[5 6 7 8]
arr2指针中存储的数组的地址：0xc0000d20a0
进程 已完成，退出代码为 0

演示代码案例4:

package main
import "fmt"
func main() {
  /*
    指针作为参数：
    参数的传递：值传递，引用传递
  */
  a := 10
  fmt.Println("fun1()函数调用前，a:", a)
  fun1(a)
  fmt.Println("fun1()函数调用后，a：", a)
  fun2(&a)
  fmt.Println("fun2()函数调用后，a:", a)
  arr1 := [4]int{1, 2, 3, 4}
  fmt.Println("fun3()函数调用前：", arr1)
  fun3(arr1)
  fmt.Println("fun3()函数调用后：", arr1)
  fun4(&arr1)
  fmt.Println("fun4()函数调用后：", arr1)
  //s1 := []int{1, 2, 3, 4, 5}
}
func fun4(p2 *[4]int) { // 引用传递
  fmt.Println("fun4()函数中的数组指针：", p2)
  p2[0] = 200
  fmt.Println("fun4()函数中的数组指针：", p2)
}
func fun3(arr2 [4]int) { // 值传递
  fmt.Println("fun3()函数中数组的：", arr2)
  arr2[0] = 100
  fmt.Println("fun3()函数中修改数组：", arr2)
}
func fun1(num int) { // 值传递：num = a = 10
  fmt.Println("fun1()函数中，num的值：", num)
  num = 100
  fmt.Println("fun1()函数中修改num：", num)
}
func fun2(p1 *int) { //传递的是a的地址，就是引用传递
  fmt.Println("fun2()函数中，p1：", *p1)
  *p1 = 200
  fmt.Println("fun2()函数中，修改p1：", *p1)
}

运行截图:

运行结果:

GOROOT=D:\Go #gosetup
GOPATH=C:\Users\DELL\go #gosetup
D:\Go\bin\go.exe build -o C:\Users\DELL\AppData\Local\JetBrains\GoLand2023.1\tmp\GoLand\___go_build_Day17_Pointer__3_.exe D:\GolandProjects\Day17-Pointer\demo04_pointerparamter.go #gosetup
C:\Users\DELL\AppData\Local\JetBrains\GoLand2023.1\tmp\GoLand\___go_build_Day17_Pointer__3_.exe
fun1()函数调用前，a: 10
fun1()函数中，num的值： 10
fun1()函数中修改num： 100
fun1()函数调用后，a： 10
fun2()函数中，p1： 10
fun2()函数中，修改p1： 200
fun2()函数调用后，a: 200
fun3()函数调用前： [1 2 3 4]
fun3()函数中数组的： [1 2 3 4]
fun3()函数中修改数组： [100 2 3 4]
fun3()函数调用后： [1 2 3 4]
fun4()函数中的数组指针： &[1 2 3 4]
fun4()函数中的数组指针： &[200 2 3 4]
fun4()函数调用后： [200 2 3 4]
进程 已完成，退出代码为 0

今日学习总结:

在本篇学习中，我们深入学习了Go语言中指针的概念和用法。我们了解了指针的基本概念，如何获取变量的地址和声明指针。我们还学习了空指针的概念以及如何获取指针的值。进一步地，我们了解了如何通过指针来改变变量的数值以及在函数参数传递中如何使用指针。最后，我们还了解了指针的指针，这在某些特定情况下非常有用。通过多个演示代码案例，我们加深了对这些概念的理解，并通过运行截图和结果展示了指针的实际应用场景。掌握了这些知识后，相信读者在Go语言编程中会更加游刃有余。

参考文献:

  1. Donovan, A., & Kernighan, B. W. (2015). The Go Programming Language. Addison-Wesley Professional.
  • 该书由Go语言的创始人之一Alan A. A. Donovan和Brian W. Kernighan合著，对Go语言的指针及其他重要概念进行了全面介绍，是学习Go语言的经典教材之一。
  1. 温航, 张煜皓, & 张淼. (2019). Go语言学习笔记. 电子工业出版社.
  • 这本书是一本适合初学者的Go语言入门教材，其中包含了关于指针的基础知识和实例讲解。
  1. Pike, R., & Thompson, K. (2020). The Go Memory Model. arXiv preprint arXiv:2003.11757.
  • 该文献探讨了Go语言的内存模型，涉及到指针的使用和内存管理相关的内容，适合对Go语言底层原理感兴趣的读者。
  1. Young, M. (2016). The Little Go Book. The Little Go Book.
  • 这是一本小型的Go语言入门书籍，其中有关于指针的简洁介绍和示例。
  1. A Tour of Go - Pointers. (官方教程)
  • Go语言官方教程中有关于指针的章节，提供了指针的基本概念和使用方法，可作为初学者入门指针的参考资料。

结语

  • 今天已学习

通过今天的学习，您已经踏上了Golang的学习之旅。在未来的日子里，您将探索Golang的各个方面，从基础概念到高级技巧，从实际应用到性能优化。

学习一门编程语言是一个持续的过程，每一天都是您向Golang的精通迈进的重要一步。我鼓励您坚持每天学习，保持热情和好奇心，解决挑战并享受成功的喜悦。

在您的学习旅程中，不要忘记参与社区和与其他Golang开发者交流。分享您的见解和经验，向他人学习，并在开源项目或实际应用中展示您的技能。

如果您在学习过程中遇到困难或有任何问题，不要犹豫向社区和专家寻求帮助。持续学习，勇敢探索，您将在Golang领域取得令人瞩目的成就。

最后，感谢您的阅读和支持！祝愿您在未来的每一天中都能够成为一名精通Golang的开发者！

期待听到您在学习过程中的进展和成就。如果您需要进一步的帮助，请随时告诉我。祝您在学习Golang的旅程中取得巨大成功！

点击下方名片，加入IT技术核心学习团队。一起探索科技的未来，共同成长。

如果您在学习过程中有任何疑惑，请点击下方名片，带您一对一快速入门 Go语言 的世界 ~

文章标签：
云解析DNS
Go
存储
开发者
算法
关键词：
Golang语言
Go golang
Go语言
Golang go
云解析DNS语言
猫头虎
目录
相关文章
颦颦Admin@123
|
7天前
|
C语言
C语言：数组和指针笔试题解析（包括一些容易混淆的指针题目）
C语言：数组和指针笔试题解析（包括一些容易混淆的指针题目）
颦颦Admin@123
16 1
桃李春风一杯酒
|
2天前
|
存储 程序员 C语言
【C 言专栏】C 语言指针的深度解析
【4月更文挑战第30天】C 语言中的指针是程序设计的关键，它如同一把钥匙，提供直接内存操作的途径。指针是存储其他变量地址的变量，通过声明如`int *ptr`来使用。它们在动态内存分配、函数参数传递及数组操作中发挥重要作用。然而，误用指针可能导致错误，如空指针引用和内存泄漏。理解指针的运算、与数组和函数的关系，以及在结构体中的应用，是成为熟练 C 语言程序员的必经之路。虽然挑战重重，但掌握指针将增强编程效率和灵活性。不断实践和学习，我们将驾驭指针，探索更广阔的编程世界。
桃李春风一杯酒
21 12
桃李春风一杯酒
|
2天前
|
Java Go 区块链
【Go语言专栏】Go语言中的指针与内存管理
【4月更文挑战第30天】Go语言，由Google开发，是一种静态强类型、编译型、并发型语言，具有垃圾回收功能，常用于云计算、微服务、区块链等领域。本文聚焦Go中的指针和内存管理。指针表示变量内存地址，可用于直接访问和修改变量，如示例代码所示。指针运算有限制，仅支持相同类型变量和数组元素访问。内存管理由Go运行时的垃圾回收机制处理，自动回收无引用对象，简化管理但引入性能开销。可通过`runtime.GC()`手动触发垃圾回收。
桃李春风一杯酒
10 0
牵着猫散步的鼠鼠
|
7天前
|
人工智能 Go 开发者
Golang语言异常机制解析：错误策略与优雅处理
Golang语言异常机制解析：错误策略与优雅处理
牵着猫散步的鼠鼠
6 0
颦颦Admin@123
|
7天前
|
存储 C语言
指针深入解析（C语言基础）带你走进指针，了解指针
指针深入解析（C语言基础）带你走进指针，了解指针
颦颦Admin@123
6 0
颦颦Admin@123
|
7天前
|
C语言 C++
C语言：指针运算笔试题解析（包括令人费解的指针题目）
C语言：指针运算笔试题解析（包括令人费解的指针题目）
颦颦Admin@123
8 1
长梦
|
8天前
|
Java Go
Golang深入浅出之-Go语言指针面试必知：理解与使用指针
【4月更文挑战第21天】Go语言中的指针允许直接操作内存，常用于高效数据共享和传递。本文介绍了指针的基础知识，如声明、初始化和解引用，以及作为函数参数使用。此外，讨论了`new()`与`make()`的区别和内存逃逸分析。在结构体上下文中，指针用于减少复制开销和直接修改对象。理解指针与内存管理、结构体的关系及常见易错点，对于面试和编写高性能Go代码至关重要。
长梦
14 2
ohh.
|
9天前
|
存储 安全 C语言
深入解析void指针类型
深入解析void指针类型
ohh.
12 0
阿辉不一般
|
21天前
|
存储 程序员 编译器
爱上C语言：指针很难？来来来，看看这篇（基础篇）
爱上C语言：指针很难？来来来，看看这篇（基础篇）
阿辉不一般
12 0
ohh.
|
9天前
|
安全 C语言
指针与字符串：C语言中的深入探索
指针与字符串：C语言中的深入探索
ohh.
15 0

热门文章

最新文章

  • 1
    开发语言详解（python、java、Go(Golong)。。。。）
  • 2
    《Go 简易速速上手小册》第10章：微服务与云原生应用（2024 最新版）（下）
  • 3
    《Go 简易速速上手小册》第1章：Go 语言基础（2024 最新版）（上）
  • 4
    Sublime Text 3配置Go语言开发环境
  • 5
    《Go 简易速速上手小册》第6章：错误处理和测试（2024 最新版）（上）
  • 6
    推荐一款go语言的开源物联网框架-opengw
  • 7
    《Go 简易速速上手小册》第10章：微服务与云原生应用（2024 最新版）（上）
  • 8
    掌握Go语言：精通Go语言范围（range），高级应用及进销存系统实战（25）
  • 9
    掌握Go语言：Go语言通道，并发编程的利器与应用实例（20）
  • 10
    使用Go语言和chromedp库下载Instagram图片：简易指南
  • 1
    Git 术语解析：深入理解上游分支
    92
  • 2
    敏捷开发：解析灵活而高效的软件开发方法
    48
  • 3
    TiDB适用场景解析：海量数据存储与高并发读写的利器
    292
  • 4
    深入学习 XML 解析器及 DOM 操作技术
    72
  • 5
    Python基础算法解析：支持向量机（SVM）
    36
  • 6
    探索Java并发编程：Fork/Join框架的深度解析
    25
  • 7
    视觉智能平台常见问题之图片解析出的水印图判断是自己添加的水印图如何解决
    22
  • 8
    Java必刷入门递归题×5（内附详细递归解析图）
    23
  • 9
    【进阶C语言】数组笔试题解析
    19
  • 10
    哲学家解析Sora本质，AI视频离世界模拟器还有多远？
    29

    • 相关课程

    更多
  • 第八届大学生创新创业大赛阿里命题IoT赛题解析
  • 云计算工程师解析与实战-网络专家篇（体验版）
  • 深入解析Docker容器化技术
  • Java面试疑难点解析 - 面试技巧及语言基础
  • Java面试疑难点解析 - Java Web开发
  • Java面试疑难点解析 - 系统架构及项目设计

    • 相关电子书

    更多
  • ECS块储存产品全面解析
  • 阿里云HBase产品体系架构及特性解析
  • Golang 微服务在腾讯游戏用户运营领域的探索及实践

    • 相关实验场景

    更多
  • 通过云拨测对指定服务器进行Ping/DNS监测

    • 推荐镜像

    更多
  • DNS
  • golang
  • nodejs-release
    • 下一篇
    2024年阿里云免费云服务器及学生云服务器申请教程参考