Quelle est la différence entre le langage go et le langage c sur les pointeurs ?

Différences : 1. Le langage Go peut utiliser le nouveau mot-clé pour allouer de la mémoire et créer des pointeurs de types spécifiés, mais le langage C ne le peut pas. 2. Le nom du tableau arr en langage C représente l'adresse du premier élément du tableau, ce qui équivaut à "&arr[0]" ; le nom du tableau arr en langage Go ne représente pas l'adresse du premier élément de le tableau, mais représente la valeur du tableau entier. 3. Le langage Go ne prend pas en charge l'arithmétique des pointeurs, mais le langage C prend en charge l'arithmétique des pointeurs. 4.

L'environnement d'exploitation de ce tutoriel : système Windows 7, GO version 1.18, ordinateur Dell G3.

C et Go sont tous deux des langages avec des concepts de pointeurs. Cet article utilise principalement les similitudes et les différences entre les deux pour approfondir la compréhension et l'utilisation des pointeurs Go.

Operator

C et Go sont identiques :

• L'opérateur & extrait l'adresse mémoire où se trouve la variable& 运算符取出变量所在的内存地址

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

C 语言版示例：

#include <stdio.h>

int main()
{
    int bar = 1;
    // 声明一个指向 int 类型的值的指针
    int *ptr;
    // 通过 & 取出 bar 变量所在的内存地址并赋值给 ptr 指针
    ptr = &bar;
    // 打印 ptr 的值（为地址），*prt 表示取出指针变量所指向的内存地址里面的值
    printf("%p %d\n", ptr, *ptr);
    return (0);
}

// 输出结果：
// 0x7ffd5471ee54 1

Go 语言版示例：

package main

import "fmt"

func main() {
 bar := 1
 // 声明一个指向 int 类型的值的指针
 var ptr *int
 // 通过 & 取出 bar 变量所在的内存地址并赋值给 ptr 指针
 ptr = &bar
 // 打印 ptr 变量储存的指针地址，*prt 表示取出指针变量所指向的内存地址里面的值
 fmt.Printf("%p %d\n", ptr, *ptr)
}

// 输出结果：
// 0xc000086020 1

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

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

数组名和数组首地址

对于一个数组

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

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

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

// C
// arr 数组名代表数组首元素的地址
printf("arr -> %p\n", arr);
// &arr[0] 代表数组首元素的地址
printf("&arr[0] -> %p\n", &arr[0]);
// &arr 代表整个数组 arr 的首地址
printf("&arr -> %p\n", &arr);

// 输出结果：
// arr -> 0061FF0C
// &arr[0] -> 0061FF0C
// &arr -> 0061FF0C

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

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

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

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

// C
// 指针偏移
printf("arr+1 -> %p\n", arr + 1);
printf("&arr+1 -> %p\n", &arr + 1);

// 输出结果：
// arr+1 -> 0061FF10
// &arr+1 -> 0061FF20

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

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

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

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

// 尝试将数组名 arr 作为地址输出
fmt.Printf("arr -> %p\n", arr)
fmt.Printf("&arr[0] -> %p\n", &arr[0])
fmt.Printf("&arr -> %p\n", &arr)

// 输出结果：
// arr -> %!p([5]int=[1 2 3 4 5])
// &arr[0] -> 0xc00000c300
// &arr -> 0xc00000c300

&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 语言示例：

#include <stdio.h>

int main()
{
    int arr[] = {1, 2, 3, 4, 5};
    // ptr 是一个指针，为 arr 数组的第一个元素地址
    int *ptr = arr;
    printf("%p %d\n", ptr, *ptr);

    // ptr 指针向高位移动一个单位，移向到 arr 数组第二个元素地址
    ptr++;
    printf("%p %d\n", ptr, *ptr);
    return (0);
}

// 输出结果：
// 0061FF08 1
// 0061FF0C 2

在这里 ptr++ 从 0061FF08 移动了 sizeof(int) = 4 个字节到 0061FF0C

* code> opération L'opérateur extrait la valeur dans l'adresse mémoire pointée par la variable pointeur, également appelée "

déréférence🎜"🎜🎜Exemple de version en langage C : 🎜

package main

import "fmt"

func main() {
 arr := [5]uint32{1, 2, 3, 4, 5}

 // ptr 是一个指针，为 arr 数组的第一个元素地址
 ptr := &arr[0]
 fmt.Println(ptr, *ptr)

 // ptr 指针向高位移动一个单位，移向到 arr 数组第二个元素地址
 ptr++
 fmt.Println(ptr, *ptr)
}

// 输出结果：
// 编译报错：
// .\main.go:13:5: invalid operation: ptr++ (non-numeric type *uint32)

🎜Exemple de version en langage Go : 🎜

func Alignof(x ArbitraryType) uintptr
func Offsetof(x ArbitraryType) uintptr
func Sizeof(x ArbitraryType) uintptr
type ArbitraryType
func Slice(ptr *ArbitraryType, len IntegerType) []ArbitraryType
type IntegerType
type Pointer
func Add(ptr Pointer, len IntegerType) Pointer

🎜Allez OK Utilisez le mot-clé new pour allouer de la mémoire et créer un pointeur du type spécifié. 🎜

package main

import (
 "fmt"
 "unsafe"
)

func main() {
 arr := [5]uint32{1, 2, 3, 4, 5}

 ptr := &arr[0]

 // ptr(*uint32类型) => one(unsafe.Pointer类型)
 one := unsafe.Pointer(ptr)
 // one(unsafe.Pointer类型) => *uint32
 fmt.Println(one, *(*uint32)(one))

 // one(unsafe.Pointer类型) => one(uintptr类型) 后向高位移动 unsafe.Sizeof(arr[0]) = 4 字节
 // twoUintptr := uintptr(one) + unsafe.Sizeof(arr[0])
 // ！！twoUintptr 不能作为临时变量
 // uintptr 类型的临时变量只是一个无符号整数，并不知道它是一个指针地址，可能被 GC
 // 运算完成后应该直接转换回 unsafe.Pointer :
 two := unsafe.Pointer(uintptr(one) + unsafe.Sizeof(arr[0]))
 fmt.Println(two, *(*uint32)(two))
}

// 输出结果：
// 0xc000012150 1
// 0xc000012154 2

🎜🎜Nom du tableau et première adresse du tableau🎜🎜🎜Pour un tableau🎜

// model/model.go

package model

import (
 "fmt"
)

type M struct {
 foo uint32
 bar uint32
}

func (m M) Print() {
 fmt.Println(m.foo, m.bar)
}

// main.go

package main

import (
 "example/model"
 "unsafe"
)

func main() {
 m := model.M{}
 m.Print()

 foo := unsafe.Pointer(&m)
 *(*uint32)(foo) = 1
 bar := unsafe.Pointer(uintptr(foo) + 4)
 *(*uint32)(bar) = 2

 m.Print()
}

// 输出结果：
// 0 0
// 1 2

🎜En C, le nom du tableau arr représente l'adresse du premier élément du tableau, ce qui est équivalent à &arr[0] 🎜🎜Et &arr représente la première adresse de l'ensemble du tableau arr🎜

// slice 切片的底层结构
type slice struct {
 // 底层是一个数组指针
 array unsafe.Pointer
 // 长度
 len int
 // 容量
 cap int
}

🎜L'exécution du programme peut trouver la sortie de arr et &arr Les valeurs sont les mêmes, mais leurs significations sont complètement différentes. 🎜🎜Tout d'abord, le nom du tableau arr comme identifiant est l'adresse de arr[0], du point de vue de &arr[0] Un pointeur vers une valeur de type int. 🎜🎜Et &arr est un pointeur vers une valeur de type int[5]. 🎜🎜Vous pouvez vérifier davantage le décalage du pointeur🎜rrreee🎜Cela implique la connaissance du décalage : le mouvement d'un pointeur de type T est basé sur sizeof(T) code> est pour unités mobiles. 🎜🎜🎜🎜<code>arr+1 : arr est un pointeur pointant vers une valeur de type int, donc le décalage est 1*sizeof(int)🎜🎜 🎜&arr+1 : &arr est un pointeur pointant vers int[5], son offset est 1*sizeof(int)*5🎜 🎜Je pense que vous devriez être capable de comprendre la différence entre arr et &arr en langage C. Ensuite, jetons un coup d'œil au langage Go🎜rrreee🎜&arr [. 0] et &arr sont cohérents avec le langage C. 🎜🎜Mais le nom du tableau arr dans Go n'est plus l'adresse du premier élément du tableau. Il représente la valeur de l'ensemble du tableau, donc lors de la sortie, il affichera %!p. ([5]int= [1 2 3 4 5])🎜🎜🎜Arithmétique du pointeur🎜🎜🎜Un pointeur est essentiellement un entier non signé, représentant une adresse mémoire. 🎜🎜Des pointeurs et des valeurs entières peuvent être ajoutés et soustraits, comme dans l'exemple de décalage de pointeur ci-dessus : 🎜🎜🎜🎜Ajouter n : un pointeur de type T, Déplacer à la position haute en unités de n*sizeof(T). 🎜🎜🎜Moins n : Un pointeur de type T se déplace vers le bit inférieur en unités de n*sizeof(T) . 🎜🎜où sizeof(T) représente les octets occupés par le type de données, par exemple, int est de 4 octets dans un format 32 bits environnement, 8 octets dans un environnement 64 bits 🎜🎜Exemple de langage C : 🎜rrreee🎜Ici, ptr++ a déplacé sizeof(int) = 4 de 0061FF08 code> octets vers 0061FF0C, pointant vers l'adresse de l'élément suivant du tableau🎜🎜Exemple de langage Go :🎜

package main

import "fmt"

func main() {
 arr := [5]uint32{1, 2, 3, 4, 5}

 // ptr 是一个指针，为 arr 数组的第一个元素地址
 ptr := &arr[0]
 fmt.Println(ptr, *ptr)

 // ptr 指针向高位移动一个单位，移向到 arr 数组第二个元素地址
 ptr++
 fmt.Println(ptr, *ptr)
}

// 输出结果：
// 编译报错：
// .\main.go:13:5: invalid operation: ptr++ (non-numeric type *uint32)

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

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

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

另辟蹊径

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

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

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

func Alignof(x ArbitraryType) uintptr
func Offsetof(x ArbitraryType) uintptr
func Sizeof(x ArbitraryType) uintptr
type ArbitraryType
func Slice(ptr *ArbitraryType, len IntegerType) []ArbitraryType
type IntegerType
type Pointer
func Add(ptr Pointer, len IntegerType) Pointer

核心介绍：

• 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 即可

代码实现：

package main

import (
 "fmt"
 "unsafe"
)

func main() {
 arr := [5]uint32{1, 2, 3, 4, 5}

 ptr := &arr[0]

 // ptr(*uint32类型) => one(unsafe.Pointer类型)
 one := unsafe.Pointer(ptr)
 // one(unsafe.Pointer类型) => *uint32
 fmt.Println(one, *(*uint32)(one))

 // one(unsafe.Pointer类型) => one(uintptr类型) 后向高位移动 unsafe.Sizeof(arr[0]) = 4 字节
 // twoUintptr := uintptr(one) + unsafe.Sizeof(arr[0])
 // ！！twoUintptr 不能作为临时变量
 // uintptr 类型的临时变量只是一个无符号整数，并不知道它是一个指针地址，可能被 GC
 // 运算完成后应该直接转换回 unsafe.Pointer :
 two := unsafe.Pointer(uintptr(one) + unsafe.Sizeof(arr[0]))
 fmt.Println(two, *(*uint32)(two))
}

// 输出结果：
// 0xc000012150 1
// 0xc000012154 2

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

// model/model.go

package model

import (
 "fmt"
)

type M struct {
 foo uint32
 bar uint32
}

func (m M) Print() {
 fmt.Println(m.foo, m.bar)
}

// main.go

package main

import (
 "example/model"
 "unsafe"
)

func main() {
 m := model.M{}
 m.Print()

 foo := unsafe.Pointer(&m)
 *(*uint32)(foo) = 1
 bar := unsafe.Pointer(uintptr(foo) + 4)
 *(*uint32)(bar) = 2

 m.Print()
}

// 输出结果：
// 0 0
// 1 2

小 Tips

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

// slice 切片的底层结构
type slice struct {
 // 底层是一个数组指针
 array unsafe.Pointer
 // 长度
 len int
 // 容量
 cap int
}

总结

• Go 可以使用 & 运算符取地址，也可以使用 new 创建指针

• Go 的数组名不是首元素地址

• Go 的指针不支持运算

• Go 可以使用 unsafe 包打破安全机制来操控指针，但对我们开发者而言，是 "unsafe" 不安全的

更多编程相关知识，请访问：编程视频！！

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!