Comment utiliser les pointeurs dans Go ?

Les pointeurs sont un concept important dans le langage Go et sont souvent utilisés pour l'accès indirect et la modification de variables. L'utilisation de pointeurs peut améliorer l'efficacité et la flexibilité du programme, mais si vous n'y prêtez pas attention, cela peut entraîner des erreurs et des problèmes. Cet article présentera les concepts de base et l'utilisation des pointeurs dans le langage Go, et l'expliquera avec des exemples de code.

1. Le concept et la définition des pointeurs

En langage Go, un pointeur est une variable qui stocke l'adresse mémoire d'une variable. Autrement dit, un pointeur est une variable dont la valeur est l'adresse d'une autre variable. La variable pointée par le pointeur peut être n'importe quel type de variable, y compris les types de base et les types composites.

Les variables de type pointeur doivent être déclarées avec "*" pour indiquer qu'il s'agit d'une variable pointeur, par exemple :

var p *int  //声明一个整型指针变量p

Dans le code ci-dessus, p est un pointeur vers un entier Une variable pointeur de type variable, mais p ne pointe actuellement vers aucune variable. Si vous devez pointer p vers une variable entière, vous pouvez utiliser le symbole d'adresse "&" pour obtenir l'adresse de la variable, puis l'attribuer à p, par exemple :

var a int = 10
p = &a   //a的地址赋值给p

Dans ce qui précède code, p pointe vers la variable L'adresse de a est accessible via le symbole de déréférence "*" pour accéder à la valeur de la variable pointée par p, par exemple :

fmt.Println(*p)  //输出p所指向的变量a的值，即10

2. Fonctionnement et utilisation de pointeurs

1. Passage de pointeurs

En langage Go, les pointeurs peuvent être passés en tant que paramètres de fonction. Le fonctionnement des variables pointeurs dans la fonction affectera directement la valeur de la variable correspondante en dehors de la fonction, par exemple :

func changeValue(p *int) {
    *p = 20  //通过解引用符号来修改p所指向的变量的值
}

func main() {
    var a int = 10
    var p *int = &a
    changeValue(p)  //传递指针p给函数
    fmt.Println(a)  //输出修改后的a的值，即20
}

Dans le code ci-dessus, le pointeur p est passé à la fonction changeValue, et le le pointeur p est modifié dans la fonction. La valeur de la variable pointée affecte finalement la valeur de la variable a en dehors de la fonction. Étant donné que le pointeur transmet l'adresse dans le programme, la valeur de la variable peut être modifiée dans la fonction via le pointeur, affectant les variables externes de la fonction.

2. Comparaison des pointeurs

En langage Go, vous pouvez utiliser les opérateurs "==" et "!=" pour comparer des pointeurs. Si les adresses de deux pointeurs pointant vers la même variable sont identiques, alors elles sont égales, par exemple :

var a int = 10
var p1 *int = &a
var p2 *int = &a
fmt.Println(p1 == p2)  //输出true，因为p1和p2都指向变量a的地址

Dans le code ci-dessus, p1 et p2 pointent tous deux vers l'adresse de la variable a, donc ils sont égaux.

3. Valeur NULL du pointeur

En langage Go, une variable pointeur peut se voir attribuer une valeur nulle nil, indiquant que le pointeur ne pointe vers aucune variable, par exemple :

var p *int = nil

Dans le code ci-dessus, p est une variable de pointeur entier. Attribuer une valeur nulle signifie que p ne pointe vers aucune variable. Si un programme tente de déréférencer un pointeur nul, une erreur d'exécution en résultera.

4. Découpage de pointeurs

En langage Go, les pointeurs peuvent être stockés et exploités comme des éléments de tranches. Par exemple :

var a int = 10
var b int = 20
var p1 *int = &a
var p2 *int = &b
var slice []*int = []*int{p1, p2}  //声明指向整型指针变量的切片
fmt.Println(*slice[0])  //输出p1指向的变量的值，即10
fmt.Println(*slice[1])  //输出p2指向的变量的值，即20

Dans le code ci-dessus, une tranche pointant vers une variable pointeur entier est déclarée, les variables p1 et p2 sont stockées dans la tranche, et les valeurs des variables vers lesquelles elles pointent est accessible via les éléments slice .

3. Résumé

Cet article présente le concept, la définition et les opérations de base des pointeurs en langage Go. Les pointeurs sont une fonctionnalité puissante qui peut améliorer l'efficacité et la flexibilité des programmes, mais vous devez également faire attention à leur utilisation pour éviter des problèmes tels que des erreurs de pointeur et des pointeurs suspendus. Dans le langage Go, il est recommandé d'éviter d'utiliser des pointeurs pour exploiter des types de données composites tels que le découpage et le mappage, ce qui peut améliorer la sécurité et la lisibilité du code.

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!