web-dev-qa-db-de.com

Wie bekomme ich die Speichergröße der Variablen?

Weiß jemand, wie die Speichergröße der Variablen (int, string, []struct usw.) abgerufen und gedruckt wird? Ist es möglich?

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
16

Sie können die Funktion unsafe.Sizeof für diese Funktion verwenden. Sie gibt die Größe in Bytes zurück, die mit dem Wert belegt ist, den Sie in sie übergeben haben. Hier ist ein Arbeitsbeispiel :

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))
}

Beachten Sie, dass einige Plattformen die Verwendung von unsicherem Computer explizit nicht zulassen, da dies nicht sicher ist. Dies beinhaltete AppEngine. Ich bin mir nicht sicher, ob das heute noch der Fall ist, aber ich stelle mir das so vor.

Wie @ Timur Fayzrakhmanov feststellt, gibt Ihnen reflect.TypeOf(variable).Size() die gleichen Informationen. Für das Paket reflect gilt dieselbe Einschränkung wie für das Paket unsafe. I.e .: Einige Plattformen erlauben möglicherweise keine Verwendung.

29
jimt

Sie können dies entweder mit unsafe.Sizeof() oder reflect.Type.Size() tun.

10
JimB

Die Größe einer Variablen kann mit unsafe.Sizeof(a) bestimmt werden. Das Ergebnis bleibt für einen bestimmten Typ (d. H. int, int64, string, struct usw.) gleich, unabhängig von dem darin enthaltenen Wert. Für den Typ string können Sie jedoch an der Größe der Zeichenfolge interessiert sein, auf die die Variable verweist, und dies wird mithilfe der Funktion len(a) für eine bestimmte Zeichenfolge bestimmt. Der folgende Ausschnitt veranschaulicht, dass die Größe einer Variablen des Typs "string" immer 8 beträgt. Die Länge einer Zeichenfolge, auf die eine Variable verweist, kann jedoch variieren:

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))
}

Ausgabe:

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

Der letzte Teil Ihrer Frage betrifft das Zuweisen der Länge (d. H. Eines int-Werts) zu einer string. Dies kann durch s := strconv.Itoa(i) erfolgen, wobei i eine int-Variable ist und die von der Funktion zurückgegebene strings zugewiesen ist.

Hinweis: Der Name der Konverterfunktion lautet Itoa , möglicherweise eine Kurzform für Ganzzahl in ASCII. Die meisten Golang-Programmierer werden den Funktionsnamen wahrscheinlich als Iota falsch lesen.

4
Tapan Karecha

unsafe.Sizeof () ist die richtige Lösung.

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))

Die Typen int, uint und uintptr sind auf 32-Bit-Systemen normalerweise 32 Bit und auf 64-Bit-Systemen 64 Bit breit. Wenn Sie einen ganzzahligen Wert benötigen, sollten Sie int verwenden, es sei denn, Sie haben einen bestimmten Grund für die Verwendung eines ganzzahligen Typs mit oder ohne Vorzeichen.

0
Kelvin Kuo