Comment puis-je imprimer la valeur du pointeur d'un objet? Quelle est la valeur du pointeur veux dire?

Je suis en train de jouer au rendez-vous et n'ont pas encore un bon modèle mental de lorsque les structures sont passés par valeur ou par référence.

C'est peut-être une question stupide mais je veux juste s'amuser un peu et voir si je suis encore à travailler sur le même objet ou j'ai fait une copie de celui-ci (passé par valeur).

Est-il un moyen d'imprimer le pointeur (ou id interne si la valeur du pointeur est modifié par gc) d'un objet?

package main

import ( "runtime" )

type Something struct {
    number int
    queue chan int
}

func gotest( s *Something, done chan bool ) {
    println( "from gotest:")
    println( &s )
    for num := range s.queue {
        println( num )
        s.number = num
    }
    done <- true
}

func main() {
    runtime.GOMAXPROCS(4)
    s := new(Something)
    println(&s)
    s.queue = make(chan int)
    done := make(chan bool)
    go gotest(s, done)
    s.queue <- 42
    close(s.queue)
    <- done
    println(&s)
    println(s.number)
}

donne sur mon windows (8g version compilée):

0x4930d4
from gotest:
0x4974d8
42
0x4930d4
42

Pourquoi le pointeur de la valeur à partir de l'intérieur de l'aller routine afficher une valeur différente? La quantité sur l'objet d'origine ne sont modifiées de sorte qu'il a été de travailler avec le même objet. Est-il possible de voir un id de l'objet qui est persistant?

InformationsquelleAutor Jeroen Dirks | 2011-02-08

78

Aller les arguments d'une fonction sont passés par valeur.

Tout d'abord, nous allons jeter la pertinence des parties de votre exemple, de sorte que nous pouvons facilement voir que vous êtes simplement de passage d'argument par valeur. Par exemple,
```
package main

import "fmt"

func byval(q *int) {
    fmt.Printf("3. byval -- q %T: &q=%p q=&i=%p  *q=i=%v\n", q, &q, q, *q)
    *q = 4143
    fmt.Printf("4. byval -- q %T: &q=%p q=&i=%p  *q=i=%v\n", q, &q, q, *q)
    q = nil
}

func main() {
    i := int(42)
    fmt.Printf("1. main  -- i  %T: &i=%p i=%v\n", i, &i, i)
    p := &i
    fmt.Printf("2. main  -- p %T: &p=%p p=&i=%p  *p=i=%v\n", p, &p, p, *p)
    byval(p)
    fmt.Printf("5. main  -- p %T: &p=%p p=&i=%p  *p=i=%v\n", p, &p, p, *p)
    fmt.Printf("6. main  -- i  %T: &i=%p i=%v\n", i, &i, i)
}
```
De sortie:
```
1. main  -- i  int: &i=0xf840000040 i=42
2. main  -- p *int: &p=0xf8400000f0 p=&i=0xf840000040  *p=i=42
3. byval -- q *int: &q=0xf8400000d8 q=&i=0xf840000040  *q=i=42
4. byval -- q *int: &q=0xf8400000d8 q=&i=0xf840000040  *q=i=4143
5. main  -- p *int: &p=0xf8400000f0 p=&i=0xf840000040  *p=i=4143
6. main  -- i  int: &i=0xf840000040 i=4143
```
En fonction main, i est un int variable à l'emplacement de la mémoire (&i) 0xf800000040 avec une valeur initiale (i) 42.

En fonction main, p est un pointeur vers une int variable à l'emplacement de la mémoire (&p) 0xf8000000f0 avec une valeur (p=&i) 0xf800000040 qui renvoie à une int valeur (*p=i) 42.

En fonction main, byval(p) est un appel de fonction qui attribue la valeur (p=&i) 0xf800000040 de l'argument à l'emplacement de la mémoire (&p) 0xf8000000f0 à la fonction byval paramètre q à l'emplacement de la mémoire (&q) 0xf8000000d8. En d'autres termes, la mémoire est allouée pour la byval paramètre q et la valeur de la main byval argument p est assignée; les valeurs de p et q sont les mêmes au départ, mais les variables p et q sont distincts.

En fonction byval, à l'aide du pointeur de la q (*int), qui est une copie du pointeur p (*int), entier *q (i) est mis à une nouvelle valeur int 4143. À la fin avant de la retourner. le pointeur q est fixé à nil (valeur zéro), qui n'a aucun effet sur p depuis q est une copie.

En fonction main, p est un pointeur vers une int variable à l'emplacement de la mémoire (&p) 0xf8000000f0 avec une valeur (p=&i) 0xf800000040 qui pointe vers une nouvelle int valeur (*p=i) 4143.

En fonction main, i est un int variable à l'emplacement de la mémoire (&i) 0xf800000040 avec une valeur finale (i) 4143.

Dans votre exemple, la fonction main variable s utilisé comme un argument de la fonction gotest appel n'est pas la même que la fonction gotest paramètre s. Ils ont le même nom, mais sont différentes variables avec des portées différentes et des emplacements de mémoire. Le paramètre de la fonction s cache l'appel de la fonction argument s. C'est pourquoi, dans mon exemple, j'ai nommé les arguments et les variables de paramètre p et q respectivement de souligner la différence.

Dans votre exemple, (&s) 0x4930d4 est l'adresse de l'emplacement mémoire pour la variable s en fonction main qui est utilisé comme un argument à l'appel de la fonction gotest(s, done), et 0x4974d8 est l'adresse de l'emplacement mémoire pour la fonction gotest paramètre s. Si vous définissez le paramètre s = nil à la fin de la fonction gotest, il n'a pas d'effet sur la variable s dans main; s dans main et s dans gotest sont distincts des emplacements de mémoire. En termes de types, &s est **Something, s est *Something, et *s est Something. &s est un pointeur (l'adresse de l'emplacement mémoire) s, qui est un pointeur (l'adresse de l'emplacement mémoire) anonyme variable de type Something. En termes de valeurs, main.&s != gotest.&s, main.s == gotest.s, main.*s == gotest.*s, et main.s.number == gotest.s.number.

Vous devriez prendre mkb sages conseils et de cesser d'utiliser println(&s). Utiliser le fmt paquet, par exemple,
```
fmt.Printf("%v %p %v\n", &s, s, *s)
```
Les pointeurs ont la même valeur lorsqu'ils pointent vers le même emplacement de mémoire; les pointeurs ont des valeurs différentes quand ils pointent vers différents emplacements de mémoire.
- Dans mon exemple, le gotest prend un pointeur vers "quelque Chose" donc je suis en supposant qu'elle se réfère au même objet et il est clairement parce qu'après j'ai changer la valeur à l'intérieur de l'aller-routine de l'objet a également sa valeur a changé dans la fonction principale. La valeur du pointeur imprimé est différent.
- Dans votre exemple, vous avez l'impression de la valeur du pointeur &s type **quelque Chose, ce qui n'est pas la même que la valeur du pointeur de type s *quelque Chose. J'ai révisé mon exemple pour passer un pointeur en valeur.
- Dean que Vous avez imprimé l'adresse du pointeur (c'est à dire un pointeur vers le s pointeur), - les pointeurs sont passés par valeur, l'adresse de s n'est pas le même que s. Si votre gotest fonction ne println( s ) intead, il avait l'impression qu'il la valeur du pointeur.
- Oh, maintenant je vois ce qui se passe. En faisant println(&s) j'ai l'impression de l'adresse du pointeur de la souris au lieu de la valeur du pointeur. Si je l'avais fait println(s), il aurait montrer le même pointeur dans la main et de la aller de routine de la fonction.
- Exactement. En Aller comme en C, pour s *quelque Chose, il est essentiel de connaître la différence entre &s, s et s*.
- Ahh, section de résumé s'il vous plaît...
InformationsquelleAutor peterSO

En Aller, les arguments sont passés par valeur.

package main

import "fmt"

type SomeStruct struct {
    e int
}

//struct passed by value
func v(v SomeStruct) {
    fmt.Printf("v: %p %v\n", &v, v)
    v.e = 2
    fmt.Printf("v: %p %v\n", &v, v)
}

//pointer to struct passed by value
func p(p *SomeStruct) {
    fmt.Printf("p: %p %v\n", p, *p)
    p.e = 2
    fmt.Printf("p: %p %v\n", p, *p)
}

func main() {
    var s SomeStruct
    s.e = 1
    fmt.Printf("s: %p %v\n", &s, s)
    v(s)
    fmt.Printf("s: %p %v\n", &s, s)
    p(&s)
    fmt.Printf("s: %p %v\n", &s, s)
}

De sortie:

s: 0xf800000040 {1}
v: 0xf8000000e0 {1}
v: 0xf8000000e0 {2}
s: 0xf800000040 {1}
p: 0xf800000040 {1}
p: 0xf800000040 {2}
s: 0xf800000040 {2}

Cela ne semble pas juste, pourquoi je ne peux pas passer un pointeur? func f(s *SomeStruct) {
C'est à droite. Vous pouvez passer un pointeur. J'ai révisé l'exemple pour vous montrer comment.

InformationsquelleAutor peterSO

2
```
type sometype struct { }
a := sometype {}
b := int(2)
println("Ptr to a", &a)
println("Ptr to b", &b)
```
- Vous ne devriez pas utiliser la builtin println mais quelque chose de l'utilisation appropriée de l'esf package: golang.org/doc/go_spec.html#Bootstrapping
InformationsquelleAutor

package main

import "fmt"

func zeroval(ival int) {
     ival = 0
}

func zeroptr(iptr *int) {
     *iptr = 0
}

func main() {
    i := 1
    fmt.Println("initial:", i)
    zeroval(i)
    fmt.Println("zeroval:", i)
    //The &i syntax gives the memory address of i, i.e. a pointer to i.
    zeroptr(&i)
    fmt.Println("zeroptr:", i)
    //Pointers can be printed too.
    fmt.Println("pointer:", &i)
}

De SORTIE:

$ go run pointers.go
initial: 1
zeroval: 1
zeroptr: 0
pointer: 0x42131100

InformationsquelleAutor Jetlum Ajeti

0

Comment puis-je imprimer la valeur du pointeur d'un objet?
```
package main

import (
    "fmt"
)

func main() {
    a := 42
    fmt.Println(&a)
}
```
résultats dans:
```
0x1040a124
```
Quelle est la valeur du pointeur veux dire?

Selon Wikipédia:

Un pointeur fait référence à un emplacement dans la mémoire

InformationsquelleAutor 030

Vous devez vous connecter pour publier un commentaire.