浅析Go与C的指针

运算符

C 和 Go 都相同：

  • & 运算符取出变量所在的内存地址
  • * 运算符取出指针变量所指向的内存地址里面的值，也叫 “ 解引用 ”

C 语言版示例：

 
 
 
 
    
  
  
  
  
  1. #include  
    2. 
  
  
  
  
  2.  
    3. 
  
  
  
  
  3. int main() 
    4. 
  
  
  
  
  4. { 
    5. 
  
  
  
  
  5.     int bar = 1; 
    6. 
  
  
  
  
  6.     // 声明一个指向 int 类型的值的指针 
    7. 
  
  
  
  
  7.     int *ptr; 
    8. 
  
  
  
  
  8.     // 通过 & 取出 bar 变量所在的内存地址并赋值给 ptr 指针 
    9. 
  
  
  
  
  9.     ptr = &bar; 
    10. 
  
  
  
  
  10.     // 打印 ptr 的值（为地址），*prt 表示取出指针变量所指向的内存地址里面的值 
    11. 
  
  
  
  
  11.     printf("%p %d\n", ptr, *ptr); 
    12. 
  
  
  
  
  12.     return (0); 
    13. 
  
  
  
  
  13. } 
    14. 
  
  
  
  
  14.  
    15. 
  
  
  
  
  15. // 输出结果： 
    16. 
  
  
  
  
  16. // 0x7ffd5471ee54 1 
    17.

Go 语言版示例：

 
 
 
 
    
  
  
  
  
  1. package main 
    2. 
  
  
  
  
  2.  
    3. 
  
  
  
  
  3. import "fmt" 
    4. 
  
  
  
  
  4.  
    5. 
  
  
  
  
  5. func main() { 
    6. 
  
  
  
  
  6.  bar := 1 
    7. 
  
  
  
  
  7.  // 声明一个指向 int 类型的值的指针 
    8. 
  
  
  
  
  8.  var ptr *int 
    9. 
  
  
  
  
  9.  // 通过 & 取出 bar 变量所在的内存地址并赋值给 ptr 指针 
    10. 
  
  
  
  
  10.  ptr = &bar 
    11. 
  
  
  
  
  11.  // 打印 ptr 变量储存的指针地址，*prt 表示取出指针变量所指向的内存地址里面的值 
    12. 
  
  
  
  
  12.  fmt.Printf("%p %d\n", ptr, *ptr) 
    13. 
  
  
  
  
  13. } 
    14. 
  
  
  
  
  14.  
    15. 
  
  
  
  
  15. // 输出结果： 
    16. 
  
  
  
  
  16. // 0xc000086020 1 
    17.

Go 还可以使用 new 关键字来分配内存创建指定类型的指针。

 
 
 
 
    
  
  
  
  
  1. // 声明一个指向 int 类型的值的指针 
    2. 
  
  
  
  
  2. // var ptr *int 
    3. 
  
  
  
  
  3. ptr := new(int) 
    4. 
  
  
  
  
  4. // 通过 & 取出 bar 变量所在的内存地址并赋值给 ptr 指针 
    5. 
  
  
  
  
  5. ptr = &bar 
    6.

数组名和数组首地址

对于一个数组

 
 
 
 
    
  
  
  
  
  1. // C 
    2. 
  
  
  
  
  2. int arr[5] = {1, 2, 3, 4, 5}; 
    3. 
  
  
  
  
  3. // Go 
    4. 
  
  
  
  
  4. // 需要指定长度，否则类型为切片 
    5. 
  
  
  
  
  5. arr := [5]int{1, 2, 3, 4, 5} 
    6.

在 C 中，数组名 arr 代表的是数组首元素的地址，相当于 &arr[0]

而 &arr 代表的是整个数组 arr 的首地址

 
 
 
 
    
  
  
  
  
  1. // C 
    2. 
  
  
  
  
  2. // arr 数组名代表数组首元素的地址 
    3. 
  
  
  
  
  3. printf("arr -> %p\n", arr); 
    4. 
  
  
  
  
  4. // &arr[0] 代表数组首元素的地址 
    5. 
  
  
  
  
  5. printf("&arr[0] -> %p\n", &arr[0]); 
    6. 
  
  
  
  
  6. // &arr 代表整个数组 arr 的首地址 
    7. 
  
  
  
  
  7. printf("&arr -> %p\n", &arr); 
    8. 
  
  
  
  
  8.  
    9. 
  
  
  
  
  9. // 输出结果： 
    10. 
  
  
  
  
  10. // arr -> 0061FF0C 
    11. 
  
  
  
  
  11. // &arr[0] -> 0061FF0C 
    12. 
  
  
  
  
  12. // &arr -> 0061FF0C 
    13.

运行程序可以发现 arr 和 &arr 的输出值是相同的，但是它们的意义完全不同。

首先数组名 arr 作为一个标识符，是 arr[0] 的地址，从 &arr[0] 的角度去看就是一个指向 int 类型的值的指针。

而 &arr 是一个指向 int[5] 类型的值的指针。

可以进一步对其进行指针偏移验证

 
 
 
 
    
  
  
  
  
  1. // C 
    2. 
  
  
  
  
  2. // 指针偏移 
    3. 
  
  
  
  
  3. printf("arr+1 -> %p\n", arr + 1); 
    4. 
  
  
  
  
  4. printf("&arr+1 -> %p\n", &arr + 1); 
    5. 
  
  
  
  
  5.  
    6. 
  
  
  
  
  6. // 输出结果： 
    7. 
  
  
  
  
  7. // arr+1 -> 0061FF10 
    8. 
  
  
  
  
  8. // &arr+1 -> 0061FF20 
    9.

这里涉及到偏移量的知识：一个类型为 T 的指针的移动，是以 sizeof(T) 为移动单位的。

  • arr+1 : arr 是一个指向 int 类型的值的指针，因此偏移量为 1*sizeof(int)
  • &arr+1 : &arr 是一个指向 int[5] 的指针，它的偏移量为 1*sizeof(int)*5

到这里相信你应该可以理解 C 语言中的 arr 和 &arr 的区别了吧，接下来看看 Go 语言

 
 
 
 
    
  
  
  
  
  1. // 尝试将数组名 arr 作为地址输出 
    2. 
  
  
  
  
  2. fmt.Printf("arr -> %p\n", arr) 
    3. 
  
  
  
  
  3. fmt.Printf("&arr[0] -> %p\n", &arr[0]) 
    4. 
  
  
  
  
  4. fmt.Printf("&arr -> %p\n", &arr) 
    5. 
  
  
  
  
  5.  
    6. 
  
  
  
  
  6. // 输出结果： 
    7. 
  
  
  
  
  7. // arr -> %!p([5]int=[1 2 3 4 5]) 
    8. 
  
  
  
  
  8. // &arr[0] -> 0xc00000c300 
    9. 
  
  
  
  
  9. // &arr -> 0xc00000c300 
    10.

&arr[0] 和 &arr 与 C 语言一致。

但是数组名 arr 在 Go 中已经不是数组首元素的地址了，代表的是整个数组的值，所以输出时会提示 %!p([5]int=[1 2 3 4 5])

指针运算

指针本质上就是一个无符号整数，代表了内存地址。

指针和整数值可以进行加减法运算，比如上文的指针偏移例子：

  • 加n : 一个类型为 T 的指针，以 n*sizeof(T) 为单位向高位移动。
  • 减n : 一个类型为 T 的指针，以 n*sizeof(T) 为单位向低位移动。

其中 sizeof(T) 代表的是数据类型占据的字节，比如 int 在 32 位环境下为 4 字节，64 位环境下为 8 字节

C 语言示例：

 
 
 
 
    
  
  
  
  
  1. #include  
    2. 
  
  
  
  
  2.  
    3. 
  
  
  
  
  3. int main() 
    4. 
  
  
  
  
  4. { 
    5. 
  
  
  
  
  5.     int arr[] = {1, 2, 3, 4, 5}; 
    6. 
  
  
  
  
  6.     // ptr 是一个指针，为 arr 数组的第一个元素地址 
    7. 
  
  
  
  
  7.     int *ptr = arr; 
    8. 
  
  
  
  
  8.     printf("%p %d\n", ptr, *ptr); 
    9. 
  
  
  
  
  9.  
    10. 
  
  
  
  
  10.     // ptr 指针向高位移动一个单位，移向到 arr 数组第二个元素地址 
    11. 
  
  
  
  
  11.     ptr++; 
    12. 
  
  
  
  
  12.     printf("%p %d\n", ptr, *ptr); 
    13. 
  
  
  
  
  13.     return (0); 
    14. 
  
  
  
  
  14. } 
    15. 
  
  
  
  
  15.  
    16. 
  
  
  
  
  16. // 输出结果： 
    17. 
  
  
  
  
  17. // 0061FF08 1 
    18. 
  
  
  
  
  18. // 0061FF0C 2 
    19.

在这里 ptr++ 从 0061FF08 移动了 sizeof(int) = 4 个字节到 0061FF0C ，指向了下一个数组元素的地址

Go 语言示例：

 
 
 
 
    
  
  
  
  
  1. package main 
    2. 
  
  
  
  
  2.  
    3. 
  
  
  
  
  3. import "fmt" 
    4. 
  
  
  
  
  4.  
    5. 
  
  
  
  
  5. func main() { 
    6. 
  
  
  
  
  6.  arr := [5]uint32{1, 2, 3, 4, 5} 
    7. 
  
  
  
  
  7.  
    8. 
  
  
  
  
  8.  // ptr 是一个指针，为 arr 数组的第一个元素地址 
    9. 
  
  
  
  
  9.  ptr := &arr[0] 
    10. 
  
  
  
  
  10.  fmt.Println(ptr, *ptr) 
    11. 
  
  
  
  
  11.  
    12. 
  
  
  
  
  12.  // ptr 指针向高位移动一个单位，移向到 arr 数组第二个元素地址 
    13. 
  
  
  
  
  13.  ptr++ 
    14. 
  
  
  
  
  14.  fmt.Println(ptr, *ptr) 
    15. 
  
  
  
  
  15. } 
    16. 
  
  
  
  
  16.  
    17. 
  
  
  
  
  17. // 输出结果： 
    18. 
  
  
  
  
  18. // 编译报错： 
    19. 
  
  
  
  
  19. // .\main.go:13:5: invalid operation: ptr++ (non-numeric type *uint32) 
    20.

编译报错 *uint32 非数字类型，不支持运算，说明 Go 是不支持指针运算的。

这个其实在 Go Wiki[1] 中的 Go 从 C++ 过渡文档中有提到过：Go has pointers but not pointer arithmetic.

Go 有指针但不支持指针运算。

另辟蹊径

那还有其他办法吗?答案当然是有的。

在 Go 标准库中提供了一个 unsafe 包用于编译阶段绕过 Go 语言的类型系统，直接操作内存。

我们可以利用 unsafe 包来实现指针运算。

 
 
 
 
    
  
  
  
  
  1. func Alignof(x ArbitraryType) uintptr 
    2. 
  
  
  
  
  2. func Offsetof(x ArbitraryType) uintptr 
    3. 
  
  
  
  
  3. func Sizeof(x ArbitraryType) uintptr 
    4. 
  
  
  
  
  4. type ArbitraryType 
    5. 
  
  
  
  
  5. func Slice(ptr *ArbitraryType, len IntegerType) []ArbitraryType 
    6. 
  
  
  
  
  6. type IntegerType 
    7. 
  
  
  
  
  7. type Pointer 
    8. 
  
  
  
  
  8. func Add(ptr Pointer, len IntegerType) Pointer 
    9.

核心介绍：

  • uintptr : Go 的内置类型。是一个无符号整数，用来存储地址，支持数学运算。常与 unsafe.Pointer 配合做指针运算
  • unsafe.Pointer : 表示指向任意类型的指针，可以和任何类型的指针互相转换(类似 C 语言中的 void* 类型的指针)，也可以和 uintptr 互相转换
  • unsafe.Sizeof : 返回操作数在内存中的字节大小，参数可以是任意类型的表达式，例如 fmt.Println(unsafe.Sizeof(uint32(0))) 的结果为 4
  • unsafe.Offsetof : 函数的参数必须是一个字段 x.f，然后返回 f 字段相对于 x 起始地址的偏移量，用于计算结构体成员的偏移量

原理：

Go 的 uintptr 类型存储的是地址，且支持数学运算

*T (任意指针类型) 和 unsafe.Pointer 不能运算，但是 unsafe.Pointer 可以和 *T 、 uintptr 互相转换

因此，将 *T 转换为 unsafe.Pointer 后再转换为 uintptr ，uintptr 进行运算之后重新转换为 unsafe.Pointer => *T 即可

代码实现：

 
 
 
 
    
  
  
  
  
  1. package main 
    2. 
  
  
  
  
  2.  
    3. 
  
  
  
  
  3. import ( 
    4. 
  
  
  
  
  4.  "fmt" 
    5. 
  
  
  
  
  5.  "unsafe" 
    6. 
  
  
  
  
  6. ) 
    7. 
  
  
  
  
  7.  
    8. 
  
  
  
  
  8. func main() { 
    9. 
  
  
  
  
  9.  arr := [5]uint32{1, 2, 3, 4, 5} 
    10. 
  
  
  
  
  10.  
    11. 
  
  
  
  
  11.  ptr := &arr[0] 
    12. 
  
  
  
  
  12.  
    13. 
  
  
  
  
  13.  // ptr(*uint32类型) => one(unsafe.Pointer类型) 
    14. 
  
  
  
  
  14.  one := unsafe.Pointer(ptr) 
    15. 
  
  
  
  
  15.  // one(unsafe.Pointer类型) => *uint32 
    16. 
  
  
  
  
  16.  fmt.Println(one, *(*uint32)(one)) 
    17. 
  
  
  
  
  17.  
    18. 
  
  
  
  
  18.  // one(unsafe.Pointer类型) => one(uintptr类型) 后向高位移动 unsafe.Sizeof(arr[0]) = 4 字节 
    19. 
  
  
  
  
  19.  // twoUintptr := uintptr(one) + unsafe.Sizeof(arr[0]) 
    20. 
  
  
  
  
  20.  // ！！twoUintptr 不能作为临时变量 
    21. 
  
  
  
  
  21.  // uintptr 类型的临时变量只是一个无符号整数，并不知道它是一个指针地址，可能被 GC 
    22. 
  
  
  
  
  22.  // 运算完成后应该直接转换回 unsafe.Pointer : 
    23. 
  
  
  
  
  23.  two := unsafe.Pointer(uintptr(one) + unsafe.Sizeof(arr[0])) 
    24. 
  
  
  
  
  24.  fmt.Println(two, *(*uint32)(two)) 
    25. 
  
  
  
  
  25. } 
    26. 
  
  
  
  
  26.  
    27. 
  
  
  
  
  27. // 输出结果： 
    28. 
  
  
  
  
  28. // 0xc000012150 1 
    29. 
  
  
  
  
  29. // 0xc000012154 2 
    30.

甚至还可以更改结构体的私有成员：

 
 
 
 
    
  
  
  
  
  1. // model/model.go 
    2. 
  
  
  
  
  2.  
    3. 
  
  
  
  
  3. package model 
    4. 
  
  
  
  
  4.  
    5. 
  
  
  
  
  5. import ( 
    6. 
  
  
  
  
  6.  "fmt" 
    7. 
  
  
  
  
  7. ) 
    8. 
  
  
  
  
  8.  
    9. 
  
  
  
  
  9. type M struct { 
    10. 
  
  
  
  
  10.  foo uint32 
    11. 
  
  
  
  
  11.  bar uint32 
    12. 
  
  
  
  
  12. } 
    13. 
  
  
  
  
  13.  
    14. 
  
  
  
  
  14. func (m M) Print() { 
    15. 
  
  
  
  
  15.  fmt.Println(m.foo, m.bar) 
    16. 
  
  
  
  
  16. } 
    17. 
  
  
  
  
  17.  
    18. 
  
  
  
  
  18. // main.go 
    19. 
  
  
  
  
  19.  
    20. 
  
  
  
  
  20. package main 
    21. 
  
  
  
  
  21.  
    22. 
  
  
  
  
  22. import ( 
    23. 
  
  
  
  
  23.  "example/model" 
    24. 
  
  
  
  
  24.  "unsafe" 
    25. 
  
  
  
  
  25. ) 
    26. 
  
  
  
  
  26.  
    27. 
  
  
  
  
  27. func main() { 
    28. 
  
  
  
  
  28.  m := model.M{} 
    29. 
  
  
  
  
  29.  m.Print() 
    30. 
  
  
  
  
  30.  
    31. 
  
  
  
  
  31.  foo := unsafe.Pointer(&m) 
    32. 
  
  
  
  
  32.  *(*uint32)(foo) = 1 
    33. 
  
  
  
  
  33.  bar := unsafe.Pointer(uintptr(foo) + 4) 
    34. 
  
  
  
  
  34.  *(*uint32)(bar) = 2 
    35. 
  
  
  
  
  35.  
    36. 
  
  
  
  
  36.  m.Print() 
    37. 
  
  
  
  
  37. } 
    38. 
  
  
  
  
  38.  
    39. 
  
  
  
  
  39. // 输出结果： 
    40. 
  
  
  
  
  40. // 0 0 
    41. 
  
  
  
  
  41. // 1 2 
    42.

小 Tips

Go 的底层 slice 切片源码就使用了 unsafe 包

 
 
 
 
    
  
  
  
  
  1. // slice 切片的底层结构 
    2. 
  
  
  
  
  2. type slice struct { 
    3. 
  
  
  
  
  3.  // 底层是一个数组指针 
    4. 
  
  
  
  
  4.  array unsafe.Pointer 
    5. 
  
  
  
  
  5.  // 长度 
    6. 
  
  
  
  
  6.  len int 
    7. 
  
  
  
  
  7.  // 容量 
    8. 
  
  
  
  
  8.  cap int 
    9. 
  
  
  
  
  9. } 
    10.

总结

  • Go 可以使用 & 运算符取地址，也可以使用 new 创建指针
  • Go 的数组名不是首元素地址
  • Go 的指针不支持运算
  • Go 可以使用 unsafe 包打破安全机制来操控指针，但对我们开发者而言，是 "unsafe" 不安全的

参考资料

[1]Go Wiki: https://github.com/golang/go/wiki/GoForCPPProgrammers

本文转载自微信公众号「寻寻觅觅的Gopher」，可以通过以下二维码关注。转载本文请联系寻寻觅觅的Gopher公众号。

名称栏目：浅析Go与C的指针
本文链接：http://www.csdahua.cn/qtweb/news48/449248.html

网站建设、网络推广公司-快上网，是专注品牌与效果的网站制作，网络营销seo公司；服务项目有等

广告

声明：本网站发布的内容（图片、视频和文字）以用户投稿、用户转载内容为主，如果涉及侵权请尽快告知，我们将会在第一时间删除。文章观点不代表本网站立场，如需处理请联系客服。电话：028-86922220；邮箱：631063699@qq.com。内容未经允许不得转载，或转载时需注明来源： 快上网

成都快上网为您推荐相关内容

定制网站知识

分类信息网

成都SEO优化公司　　 　东电技改　　 　网络推广公司　　 　重庆企业网站建设　　 　电商网站建设　　 　成都营销网站建设　　 　公司logo设计　　 　温江网站设计　　 　小程序　　 　轻质隔墙板　　 　盐亭做网站　　 　成都网站建设公司　　 　成都租用服务器　　 　铁科精智测控　　 　公路钻孔机　　 　品牌网站建设　　 　云服务器香港　　 　四川成都托管服务器　　 　成都网站建设　　 　泸州洋跃建站