web-dev-qa-db-fra.com

Comment obtenir la taille de la mémoire de la variable?

Quelqu'un sait-il comment obtenir la taille de la mémoire de la variable (int, string, []struct, etc.) et l'imprimer? C'est possible?

var i int = 1
//I want to get something like this:
fmt.Println("Size of i is: %?", i)
//Also, it would be Nice if I could store the value into a string
memory-managementgoruntime
16
Timur Fayzrakhmanov

Vous pouvez utiliser la fonction unsafe.Sizeof pour this . Elle renvoie la taille en octets, occupée par la valeur que vous y entrez . Voici un exemple de travail :

package main

import "fmt"
import "unsafe"

func main() {
    a := int(123)
    b := int64(123)
    c := "foo"
    d := struct {
        FieldA float32
        FieldB string
    }{0, "bar"}

    fmt.Printf("a: %T, %d\n", a, unsafe.Sizeof(a))
    fmt.Printf("b: %T, %d\n", b, unsafe.Sizeof(b))
    fmt.Printf("c: %T, %d\n", c, unsafe.Sizeof(c))
    fmt.Printf("d: %T, %d\n", d, unsafe.Sizeof(d))
}

Prenez note que certaines plates-formes interdisent explicitement l’utilisation de fichiers non sécurisés, car c’est… bien, non sécuritaires. Cela incluait AppEngine. Je ne sais pas si c'est toujours le cas aujourd'hui, mais j'imagine que oui.

Comme @Timur Fayzrakhmanov le note, reflect.TypeOf(variable).Size() vous donnera les mêmes informations. Pour le package reflect, la même restriction s'applique que pour le package unsafe. C'est-à-dire que certaines plates-formes peuvent ne pas permettre son utilisation.

29
jimt

Vous pouvez le faire avec soit unsafe.Sizeof() , ou reflect.Type.Size()

10
JimB

La taille d'une variable peut être déterminée à l'aide de unsafe.Sizeof(a). Le résultat restera le même pour un type donné (c'est-à-dire int, int64, string, struct etc.), quelle que soit la valeur qu'il détient. Toutefois, pour le type string, la taille de la chaîne référencée par la variable peut vous intéresser. Cette opération est déterminée à l'aide de la fonction len(a) sur une chaîne donnée. L'extrait suivant montre que la taille d'une variable de type chaîne est toujours égale à 8 mais que la longueur d'une chaîne référencée par une variable peut varier:

package main

import "fmt"
import "unsafe"

func main() {
    s1 := "foo"
    s2 := "foobar"

    fmt.Printf("s1 size: %T, %d\n", s1, unsafe.Sizeof(s1))
    fmt.Printf("s2 size: %T, %d\n", s2, unsafe.Sizeof(s2))
    fmt.Printf("s1 len: %T, %d\n", s1, len(s1))
    fmt.Printf("s2 len: %T, %d\n", s2, len(s2))
}

Sortie:

s1 size: string, 8
s2 size: string, 8
s1 len: string, 3
s2 len: string, 6

La dernière partie de votre question concerne l’affectation de la longueur (c’est-à-dire une valeur int) à un string. Cela peut être fait par s := strconv.Itoa(i) où i est une variable int et la string renvoyée par la fonction est affectée à s.

Remarque: le nom de la fonction de convertisseur est Itoa , éventuellement une forme abrégée pour Integer to ASCII. La plupart des programmeurs de Golang risquent de mal interpréter le nom de la fonction en tant que Iota.

4
Tapan Karecha

unsafe.Sizeof () est la solution correcte.

var i int
var u uint
var up uintptr


fmt.Printf("i Type:%T Size:%d\n", i, unsafe.Sizeof(i))
fmt.Printf("u Type:%T Size:%d\n", u, unsafe.Sizeof(u))
fmt.Printf("up Type:%T Size:%d\n", up, unsafe.Sizeof(up))

Les types int, uint et uintptr ont généralement une largeur de 32 bits sur les systèmes 32 bits et de 64 bits sur les systèmes 64 bits. Lorsque vous avez besoin d'une valeur entière, vous devez utiliser int, sauf si vous avez une raison spécifique d'utiliser un type entier de taille ou non signé.

0
Kelvin Kuo