structure d'octets Golang

La conversion d'un tableau d'octets en structure dans Golang est un problème courant que de nombreux développeurs rencontreront. Le tableau d'octets de Golang est très pratique pour traiter des données binaires, mais pour les structures de données complexes, telles que struct, un traitement manuel est nécessaire. Un tel code est long et sujet aux erreurs. Cet article explique comment convertir un tableau d'octets en structure via Golang.

1. Conversion via unsafe

Nous pouvons utiliser Pointer dans le package unsafe pour convertir entre des tableaux d'octets et des structures. L'exemple de code est le suivant :

package main

import (
    "fmt"
    "reflect"
    "unsafe"
)

type Person struct {
    Name string
    Age  int
}

func main() {
    p := Person{Name: "Tom", Age: 18}

    size := int(unsafe.Sizeof(p))
    fmt.Printf("struct size: %d
", size)

    b := make([]byte, size)
    pptr := unsafe.Pointer(&p)

    for i := 0; i < size; i++ {
        b[i] = *(*byte)(unsafe.Pointer(uintptr(pptr) + uintptr(i)))
    }

    fmt.Printf("byte array: %v
", b)

    q := (*Person)(unsafe.Pointer(&b[0]))
    fmt.Printf("person: %v
", q)
}

Dans le code ci-dessus, nous créons une structure Person, la convertissons en tableau d'octets et la reconvertissons en structure Person via un pointeur. Nous utilisons Pointer et uintptr du package unsafe pour convertir entre pointeurs et entiers.

Après avoir exécuté ce code, le résultat de sortie est le suivant :

struct size: 16
byte array: [84 111 109 0 0 0 0 0 0 0 0 0 18 0 0 0]
person: &{Tom 18}

Bien que cette méthode puisse réaliser une conversion, elle présente certains risques de sécurité et doit être utilisée avec prudence.

2. Conversion via Reflect

Le package Reflect est un package très puissant dans Golang Vous pouvez l'utiliser pour effectuer une inférence de type sur des variables et des fonctions d'appel. Lors de la conversion entre un tableau d'octets et une structure, nous pouvons utiliser Value et Type du package Reflect. L'exemple de code est le suivant :

package main

import (
    "fmt"
    "reflect"
)

type Person struct {
    Name string
    Age  int
}

func main() {
    p := Person{Name: "Tom", Age: 18}

    size := int(reflect.TypeOf(p).Size())
    fmt.Printf("struct size: %d
", size)

    b := make([]byte, size)
    reflect.ValueOf(&p).Elem().Interface()
    for i := 0; i < size; i++ {
        b[i] = *(*byte)(unsafe.Pointer(uintptr(reflect.ValueOf(&p).Elem().UnsafeAddr()) + uintptr(i)))
    }

    fmt.Printf("byte array: %v
", b)

    var q Person
    s := reflect.ValueOf(&q).Elem()
    for i := 0; i < size; i++ {
        s.Field(i).SetInt(int64(b[i]))
    }

    fmt.Printf("person: %v
", q)
}

Nous utilisons Type et Value dans le package Reflect pour obtenir la taille et la valeur de la structure, et obtenons la taille et la valeur de la structure via Reflect.ValueOf(&p ).Elem().UnsafeAddr() Pour les pointeurs en mémoire, utilisez uintptr et unsafe.Pointer pour la conversion de type, et enfin parcourez le tableau d'octets pour l'affectation, convertissant ainsi le tableau d'octets en une structure.

Après avoir exécuté ce code, le résultat de sortie est le suivant :

struct size: 16
byte array: [84 111 109 0 0 0 0 0 0 0 0 0 18 0 0 0]
person: {Tom 84}

En raison de la différence d'ordre de stockage entre le tableau d'octets et la structure, nous devons traiter manuellement l'ordre de tableau d'octets afin de convertir correctement en structure.

Summary

Il existe deux façons de convertir des tableaux d'octets et des structures dans Golang : l'une consiste à utiliser le package non sécurisé pour convertir entre des pointeurs, des entiers et des tableaux d'octets. Conversion, une consiste à convertir entre les types, les valeurs et les adresses via le package Reflect. Les deux méthodes ont leurs propres avantages et inconvénients, et vous devez choisir en fonction de la situation spécifique lors de leur utilisation. Dans le même temps, lors de la conversion de tableaux d'octets et de structures, vous devez faire attention aux détails tels que l'ordre des tableaux d'octets et les types de champs dans la structure.

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!