Comment résoudre l'erreur Golang : mémoire d'adresse invalide ou déréférencement de pointeur nul

Comment résoudre l'erreur Golang : adresse mémoire invalide ou déréférencement de pointeur nul

Au cours du processus de développement utilisant Golang, nous rencontrons souvent des erreurs, dont la plus courante est l'erreur "adresse mémoire invalide ou déréférencement de pointeur nul". Cette erreur est généralement provoquée par une référence de pointeur nulle ou une adresse mémoire illégale. Cet article couvrira quelques causes courantes et solutions.

1. Référence de pointeur nul ou pointeur non initialisé
   Dans Golang, lorsqu'un pointeur n'est pas initialisé ou attribué une valeur nulle, une opération directe sur lui provoquera cette erreur. La solution consiste à s’assurer que le pointeur a été correctement initialisé ou attribué. Voici un exemple :

var ptr *int
// ptr未初始化，直接使用会引发错误
// 通过分配一块内存给ptr来解决问题
ptr = new(int)
*ptr = 10
fmt.Println(*ptr)

2. Le récepteur de méthode est nul
   Lorsque nous utilisons la programmation orientée objet, nous définissons des structures et des méthodes. Si le récepteur de la méthode est un pointeur nul, cette erreur se produira également lors de l'appel de la méthode. La solution consiste à garantir que le récepteur de méthode est un pointeur valide non nul.

type Person struct {
    Name string
}

func (p *Person) PrintName() {
    fmt.Println(p.Name)
}

var p *Person
// p是空指针，调用PrintName方法会引发错误
p.PrintName()

3. Le découpage ou le mappage ne sont pas initialisés
   Le découpage et le mappage sont également des structures de données couramment utilisées dans Golang. Vous devez vous assurer qu'ils sont correctement initialisés lors de l'utilisation. Cette erreur se produit si les opérations sont effectuées sans initialisation appropriée. La solution consiste à utiliser la fonction make pour créer la tranche ou la carte et à s'assurer qu'elle est correctement initialisée avant utilisation.

var s []int
// s未初始化，直接使用会引发错误
// 使用make函数创建一个长度为0的切片
s = make([]int, 0)
fmt.Println(len(s))

4. Appel de méthodes via des pointeurs nuls
   Dans Golang, une méthode de structure ne peut être appelée que via un pointeur non nul. Si nous essayons d'appeler une méthode via un pointeur nul, cette erreur se produira également. La solution consiste d’abord à déterminer si le pointeur est nul avant d’appeler la méthode.

type Person struct {
    Name string
}

func (p *Person) PrintName() {
    fmt.Println(p.Name)
}

var p *Person
// p是空指针，直接调用方法会引发错误
if p != nil {
    p.PrintName()
}

5. La concurrence multithread entraîne un rapport d'erreurs
   Dans un programme simultané multithread, si plusieurs goroutines lisent et écrivent une adresse mémoire partagée en même temps, une condition de concurrence critique se produira. La solution consiste à protéger les données partagées en utilisant des opérations mutex ou atomiques pour garantir que chaque opération goroutine est sûre.

import (
    "sync"
)

var count int
var mutex sync.Mutex

func increment() {
    mutex.Lock() // 获取锁
    count++
    mutex.Unlock() // 释放锁
}

func main() {
    go increment()
    go increment()

    // 在这里等待goroutine执行完成
    time.Sleep(time.Second)

    fmt.Println(count) // 输出结果可能是1或者2
}

Résumé :
L'erreur "adresse mémoire invalide ou déréférencement de pointeur nul" est l'une des erreurs courantes dans le développement de Golang. La clé pour résoudre cette erreur est de s’assurer que le pointeur est correctement initialisé et évalué comme nul. De plus, dans la concurrence multithread, il convient de prêter attention à la protection des données partagées afin d'éviter que des situations de concurrence critique ne se produisent. Espérons que grâce à cet article, vous comprendrez mieux comment résoudre cette erreur.

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!