Golang a-t-il des pointeurs ?

golang a des pointeurs. Le langage Go offre aux programmeurs la possibilité de contrôler les pointeurs de structure de données. Sa prise en charge des pointeurs se situe entre le langage Java et le langage C/C++. Il n'annule pas la capacité du code à faire fonctionner directement des pointeurs comme Java, ni n'évite le problème. problèmes de sécurité et de fiabilité causés par l’abus de pointeurs en C/C++. Les pointeurs peuvent être divisés en deux concepts de base dans le langage Go : 1. Pointeur de type, qui permet de modifier les données de ce type de pointeur 2. Slice, qui consiste en le pointeur d'origine pointant vers l'élément de départ, le nombre d'éléments ; , et la capacité.

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

Contrairement aux langages de programmation tels que Java et .NET, le langage Go offre aux programmeurs la possibilité de contrôler les pointeurs de structure de données, mais il ne peut pas effectuer d'opérations de pointeur. Le langage Go vous permet de contrôler la structure des données d'une collection spécifique, le nombre d'allocations et le modèle d'accès à la mémoire, ce qui est très important pour construire un système fonctionnel. L'impact des pointeurs sur les performances est évident Si vous souhaitez effectuer de la programmation système, des systèmes d'exploitation ou des applications réseau, les pointeurs sont un élément indispensable.

La prise en charge des pointeurs par le langage Go se situe entre le langage Java et le langage C/C++. Elle n'annule pas la capacité du code à faire fonctionner directement les pointeurs comme le fait Java, et n'évite pas non plus l'abus de pointeurs en C/C++, ce qui garantit la sécurité. et des problèmes de fiabilité.

Le pointeur (pointeur) peut être divisé en deux concepts fondamentaux dans le langage Go :

• type pointeur, qui permet de modifier les données de ce type de pointeur. Les pointeurs peuvent être utilisés pour transférer des données directement sans copier les données. , les pointeurs de type ne peuvent pas effectuer de décalage ni d'opérations.

• Une tranche se compose d'un pointeur brut vers l'élément de départ, le nombre d'éléments et la capacité.

Bénéficiant de telles contraintes et fractionnement, les variables de type pointeur du langage Go ont les caractéristiques d'un accès efficace au pointeur sans décalage de pointeur, évitant ainsi le problème de modification illégale des données critiques. Dans le même temps, le garbage collection facilite la récupération et le recyclage des pointeurs qui ne seront pas compensés.

Les tranches ont des fonctionnalités plus puissantes que les pointeurs bruts et sont plus sûres. Lorsqu'une tranche sort des limites, le moteur d'exécution signalera un crash et fera apparaître la pile, tandis que le pointeur d'origine ne fera que s'effondrer.

Que sont les pointeurs en golang ?

Un pointeur est une variable dont la valeur est l'adresse d'une autre variable, c'est à dire l'adresse directe d'un emplacement mémoire. Comme une variable ou une constante, un pointeur doit être déclaré avant de pouvoir être utilisé pour stocker l'adresse d'une variable. La forme générale de déclaration de variable de pointeur est :

var var-name *var-type

Ici, var-type est le type de base du pointeur ; il doit s'agir d'un type de données Go valide et var-name est le nom de la variable de pointeur. L'astérisque (*) utilisé pour déclarer un pointeur est le même que l'astérisque utilisé pour la multiplication. Cependant, dans cette instruction, l'astérisque (*) est utilisé pour désigner la variable comme pointeur. Ce qui suit est une déclaration de pointeur valide :

var ip *int        /* pointer to an integer */
var fp *float32    /* pointer to a float */

Le type de données réel de la valeur de tous les pointeurs (qu'il s'agisse d'un entier, d'une virgule flottante ou d'un autre type de données) est le même, qui est un long nombre hexadécimal représentant l'adresse mémoire. La seule différence entre les pointeurs de différents types de données réside dans le type de données de la variable ou de la constante vers laquelle pointe le pointeur. [Recommandations associées : Tutoriel vidéo Go]

Comment utiliser les pointeurs ?

Il existe plusieurs opérations importantes qui seront mises en œuvre très fréquemment à l'aide de pointeurs.

• Définir une variable pointeur

• Attribuer l'adresse d'une variable à un pointeur

• Accéder enfin à la valeur de l'adresse disponible dans la variable pointeur

Cela se fait en utilisant l'opérateur unaire < code>*< /code> pour renvoyer la valeur de la variable située à l'adresse spécifiée par l'opérande. L'exemple suivant utilise ces opérations : *来返回位于操作数指定的地址的变量的值。下面的例子使用这些操作：

package main

import "fmt"

func main() {
   var a int= 20   /* actual variable declaration */
   var ip *int        /* pointer variable declaration */

   ip = &a  /* store address of a in pointer variable*/

   fmt.Printf("Address of a variable: %x\n", &a  )

   /* address stored in pointer variable */
   fmt.Printf("Address stored in ip variable: %x\n", ip )

   /* access the value using the pointer */
   fmt.Printf("Value of *ip variable: %d\n", *ip )
}

当上面的代码编译和执行时，它产生结果如下：

Address of var variable: 10328000
Address stored in ip variable: 10328000
Value of *ip variable: 20

在Go语言中的nil指针

Go编译器为指针变量分配一个Nil值，以防指针没有确切的地址分配。这是在变量声明的时候完成的。指定为nil值的指针称为nil指针。

nil指针是在几个标准库中定义的值为零的常量。参考下面的程序：

package main

import "fmt"

func main() {
   var  ptr *int

   fmt.Printf("The value of ptr is : %x\n", ptr  )
}

当上面的代码编译和执行时，它产生结果如下：

The value of ptr is 0

在大多数操作系统上，程序不允许访问地址0处的内存，因为该内存是由操作系统保留的。 然而，存储器地址0具有特殊意义；它表示指针不打算指向可访问的存储器位置。但是按照惯例，如果指针包含nil(零)值，则假设它不指向任何东西。

要检查是否为nil指针，可以使用if

if(ptr != nil)     /* succeeds if p is not nil */
if(ptr == nil)    /* succeeds if p is null */

Lorsque le code ci-dessus est compilé et exécuté, il produit le résultat suivant :

rrreee

pointeur nul en langage Go 🎜🎜🎜🎜Le compilateur Go attribue une variable de pointeur à un Nil dans le cas où le pointeur n'a pas d'adresse exacte attribuée. Cela se fait lorsque la variable est déclarée. Un pointeur spécifié comme une valeur nil est appelé un pointeur nul. 🎜🎜 Les pointeurs nil sont des constantes avec une valeur zéro définie dans plusieurs bibliothèques standards. Reportez-vous au programme ci-dessous : 🎜rrreee🎜 Lorsque le code ci-dessus est compilé et exécuté, il produit le résultat suivant : 🎜rrreee🎜 Sur la plupart des systèmes d'exploitation, le programme n'est pas autorisé à accéder à la mémoire à l'adresse 0 car Cette mémoire est réservée par le système d'exploitation. Cependant, l'adresse mémoire 0 a une signification particulière ; elle indique que le pointeur n'est pas destiné à pointer vers un emplacement mémoire accessible. Mais par convention, si un pointeur contient une valeur nulle, il est supposé ne pointer vers rien. 🎜🎜Pour vérifier s'il s'agit d'un pointeur nil, vous pouvez utiliser l'instruction if, comme indiqué ci-dessous : 🎜rrreee🎜Pour plus de connaissances sur la programmation, veuillez visiter : 🎜Programmation Vidéos🎜 ! ! 🎜

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!