Les pointeurs vs les valeurs des paramètres et valeurs de retour

En Aller il y a différentes façons de retourner un struct valeur ou d'une tranche de celui-ci. Pour les individuels, ceux que j'ai vu:

type MyStruct struct {
    Val int
}

func myfunc() MyStruct {
    return MyStruct{Val: 1}
}

func myfunc() *MyStruct {
    return &MyStruct{}
}

func myfunc(s *MyStruct) {
    s.Val = 1
}

Je comprends les différences entre ces. La première renvoie une copie de la structure, le second est un pointeur vers la structure de la valeur créée au sein de la fonction, la troisième s'attend à un existant struct être passé dans et remplace la valeur.

J'ai vu tous ces modèles être utilisée dans différents contextes, je me demandais quelles sont les meilleures pratiques à l'égard de ces. Quand souhaitez-vous utiliser qui? Par exemple, le premier pourrait être ok pour les petites structures (comme l'espace est minime), la seconde pour les plus grands. Et la troisième, si vous voulez être extrêmement efficace en terme de mémoire, parce que vous pouvez facilement réutiliser une struct exemple entre les appels. Existe-il des pratiques exemplaires pour quand utiliser?

De la même façon, la même question concernant les tranches:

func myfunc() []MyStruct {
    return []MyStruct{ MyStruct{Val: 1} }
}

func myfunc() []*MyStruct {
    return []MyStruct{ &MyStruct{Val: 1} }
}

func myfunc(s *[]MyStruct) {
    *s = []MyStruct{ MyStruct{Val: 1} }
}

func myfunc(s *[]*MyStruct) {
    *s = []MyStruct{ &MyStruct{Val: 1} }
}

Encore: quelles sont les meilleures pratiques ici. Je sais que les tranches sont toujours les pointeurs, afin de retourner un pointeur vers une tranche n'est pas utile. Cependant, dois-je retourner une tranche de struct valeurs, une tranche de pointeurs sur les structures, dois-je passer un pointeur à une tranche comme argument (un motif est utilisé dans le Aller à App Engine API)?

  • Comme tu dis, ça dépend vraiment du cas d'utilisation. Tous sont valables en fonction de la situation - est-ce un objet mutable? voulons-nous une copie ou un pointeur? etc. BTW, vous n'avez pas mentionné à l'aide de new(MyStruct) 🙂 Mais il n'y a pas de différence vraiment entre les différentes méthodes d'affectation de pointeurs et de les renvoyer.
  • C'est-à-dire sur l'ingénierie. Les structures doivent être assez grandes pour que de retourner un pointeur rend votre programme plus rapide. Il suffit de ne pas les déranger, de code, de profil, de fixer, si utile.
  • Il n'y a qu'une seule façon de retourner une valeur ou un pointeur, et c'est pour renvoyer une valeur, ou un pointeur. Comment vous allouer est une question distincte. Utilisez ce qui fonctionne pour votre situation, et d'aller écrire un peu de code avant de vous en soucier.
  • BTW, juste par curiosité je benchamrked cette. Le retour des structs vs pointeurs semble être à peu près la même vitesse, mais le passage de pointeurs de fonctions en bas de la lignes est siginificantly plus rapide. Bien que n'étant pas sur un niveau, il serait question
  • Je suppose que c'est juste bc répartition se fait en dehors de la fonction. Aussi l'analyse comparative des valeurs vs pointeurs dépend de la taille de la structure et de la mémoire des schémas d'accès après le fait. La copie en cache de la ligne de la taille est aussi rapide que vous pouvez obtenir, et de la vitesse de déréférencement de pointeurs de cache du PROCESSEUR est très différente de la référence à partir de la mémoire principale.
  • Votre App Engine exemple est intéressant. Ma réponse ci-dessous suggère qu'il doit retourner éventuellement élargi tranche comme append. Je pense App Engine ne le fait pas parce qu'il aurait à retourner un interface{} (depuis spécifiques struct type n'est connu que de façon dynamique) et les concepteurs ne veulent pas forcer l'utilisateur à taper-faire valoir un retour interface{} retour à la spécificité de ce type de tranche, parce que c'est verbeux/maladroit. C'est donc une situation particulière (redimensionnement de la tranche + élément de type non connu au moment de la compilation), qui rend pointeur de la tranche attrayant il.
  • Connexes: Pourquoi un constructeur d'Aller de l'adresse de retour?
  • merci pour l'analyse comparative des! Donc le passage de pointeurs autour est le plus rapide? Je viens de lire : segment.com/blog/... qui dit en utilisant des valeurs rend la collecte des ordures travail plus facile?
  • il dépend aussi de garder à l'esprit que ma réponse est près de 6 ans, le moteur d'exécution a changé depuis.

InformationsquelleAutor Zef Hemel | 2014-05-08
  1. 358

    tl;dr:

    • Méthodes à l'aide de récepteur pointeurs sont communs; la règle de base pour les récepteurs de la est, "en Cas de doute, utiliser un pointeur."
    • Tranches, des cartes, des chaînes, des cordes, des valeurs de la fonction, et l'interface valeurs sont mises en œuvre avec des pointeurs en interne, et un pointeur est souvent redondantes.
    • Ailleurs, utiliser des pointeurs pour les grandes structures ou des structures vous aurez à changer, et sinon transmettre des valeurs, parce que les choses ont changé par surprise par l'intermédiaire d'un pointeur est une source de confusion.

    Un cas où vous devez souvent utiliser un pointeur:

    • Récepteurs sont des pointeurs plus souvent que les autres arguments. Il n'est pas inhabituel pour les méthodes pour modifier la chose qu'ils sont appelés sur la, ou de types nommés de grandes structures, donc l'orientation est à défaut de pointeurs, sauf dans de rares cas.
      • Jeff Hodges' copyfighter outil de recherche automatique pour les non-minuscules récepteurs passé par valeur.

    Certaines situations où vous n'avez pas besoin de pointeurs:

    • Code de révision des lignes directrices suggèrent passant petites structures comme type Point struct { latitude, longitude float64 }, et peut-être même des choses un peu plus grand, comme les valeurs, sauf si la fonction que vous appelez doit être en mesure de les modifier en place.

      • Valeur sémantique d'éviter l'aliasing des situations où une affectation plus ici des modifications d'une valeur de plus par surprise.
      • Il n'est pas Allez-y pour le sacrifice propre à la sémantique pour un peu de vitesse, et parfois, passant de petites structures en valeur est en fait plus efficace, car elle évite de le cache ou les allocations de tas.
      • Allez Wiki la révision du code des commentaires page suggère passage par valeur lorsque les structures sont de petite taille et risque de le rester de cette façon.
      • Si les "grands" de coupure semble vague, il est; sans doute de nombreuses structures sont dans une gamme où un pointeur ou une valeur est OK. Comme une limite inférieure, la révision du code des observations suggèrent tranches (trois mots) sont raisonnables pour l'utiliser comme valeur de récepteurs. Comme quelque chose de plus proche de la limite supérieure, bytes.Replace prend 10 mots de args (trois tranches et un int).

    • Pour tranches, vous n'avez pas besoin de passer un pointeur pour modifier des éléments de la matrice. io.Reader.Read(p []byte) changements les octets de p, par exemple. C'est sans doute un cas particulier de "traiter peu de structures comme des valeurs", car en interne, vous êtes en passant autour d'une petite structure appelée tranche en-tête (voir Russ Cox (rsc)'explication). De même, vous n'avez pas besoin d'un pointeur à modifier une carte ou communiquer sur un canal.

    • Pour tranches vous pourrez reslice (modifier la start/longueur/capacité de), les fonctions intégrées comme append accepter une tranche de la valeur et de retour d'un nouveau. J'avais imiter; ça évite d'aliasing, de retour d'une nouvelle tranche d'aide à attirer l'attention sur le fait qu'un nouveau tableau pourraient être alloués, et il est familier pour les appelants.

      • C'est pas toujours pratique de suivre ce modèle. Certains outils comme interfaces de bases de données ou sérialiseurs devez ajouter à une tranche dont le type n'est pas connu au moment de la compilation. Ils ont parfois accepter un pointeur vers une tranche dans un interface{} paramètre.

    • Des cartes, des chaînes, des cordes, et la fonction d'interface valeurs, comme des tranches, en interne sont des références ou des structures qui contiennent des références déjà, donc si vous êtes juste essayer d'éviter d'obtenir les données sous-jacentes copié, vous n'avez pas besoin de passer des pointeurs vers eux. (rsc a écrit un post sur la façon de l'interface, les valeurs sont stockées).

      • Vous pourriez avoir besoin pour passer des pointeurs dans le cas plus rare où vous voulez modifier de l'appelant (struct: drapeau.StringVar prend un *string pour cette raison, par exemple.

    Où vous utiliser des pointeurs:

    • Examiner si votre fonction doit être une méthode selon la struct vous avez besoin d'un pointeur. Les gens attendent beaucoup de méthodes sur x de modifier x, afin de faire de la modification de la structure du récepteur peut aider à minimiser la surprise. Il y a lignes directrices sur les récepteurs doivent être des pointeurs.

    • Des fonctions qui ont des effets sur leur non-récepteur params doit l'indiquer clairement dans le godoc, ou mieux encore, la godoc et le nom (comme reader.WriteTo(writer)).

    • Vous mentionner l'acceptation d'un pointeur pour éviter les allocations en permettant la réutilisation; la modification de l'Api pour l'amour de la mémoire de la réutilisation est une optimisation que j'avais de retard jusqu'à ce qu'il est évident que les allocations ont un coût non négligeable, et puis j'aurais l'air d'un moyen qui n'a pas la force de le plus délicat de l'API sur l'ensemble des utilisateurs:

      1. Pour éviter les allocations, Go échapper à l'analyse est votre ami. Vous pouvez parfois l'aider à éviter les allocations de tas en faisant des types qui peuvent être initialisée avec un trivial constructeur, une plaine littérale, ou un zéro valeur comme octets.Tampon.
      2. Envisager une Reset() méthode pour mettre un objet dans le vide de l'état, à l'instar de certains stdlib types d'offre. Les utilisateurs qui ne se soucient pas ou ne pouvez pas enregistrer une allocation de ne pas avoir à l'appeler.
      3. Envisager d'écrire modifier en place de méthodes et de création à partir de zéro fonctions paires, pour plus de commodité: existingUser.LoadFromJSON(json []byte) error pourrait être enveloppé par NewUserFromJSON(json []byte) (*User, error). Encore une fois, il pousse le choix entre la paresse et de pincer les attributions à la personne de l'appelant.
      4. Les appelants cherchent à recycler la mémoire peut laisser sync.Piscine gérer certains détails. Si une allocation crée beaucoup de pression sur la mémoire, que vous êtes sûr de savoir quand les alloc n'est plus utilisé, et vous n'avez pas une meilleure optimisation disponibles, sync.Pool peut vous aider. (CloudFlare publié un utile (pré-sync.Piscine) post de blog sur le recyclage.)

    Enfin, si vos tranches de pointeurs: tranches de valeurs peut être utile, et vous épargner les allocations et les défauts de cache. Il peut être bloquants:

    • L'API pour créer vos éléments pourrait obliger de pointeurs sur vous, par exemple, vous devez appeler NewFoo() *Foo plutôt que de laisser Aller de l'initialiser avec la la valeur zéro.
    • Souhaité la durée de vie des éléments peut-être pas tous les mêmes. L'ensemble de la tranche est libéré à la fois; si 99% des articles ne sont plus utiles, mais vous avez des pointeurs vers d'autres 1%, l'ensemble de la matrice reste affecté.
    • En déplaçant les éléments autour de pourrait vous causer des problèmes. Notamment, append des copies des articles quand il pousse le tableau sous-jacent. Les pointeurs vous obtenu avant que le append point à la mauvaise place, après, la copie peut être plus lente pour les énormes structures, par exemple sync.Mutex la copie n'est pas autorisée. Insérer/supprimer dans le moyen et le tri de même déplacer des éléments autour.

    Globalement, la valeur des tranches de sens que si l'un de vous débarrasser de tous vos éléments en place et de ne pas les déplacer (par exemple, pas plus appends après l'installation initiale), ou si vous ne le garder de les déplacer, mais vous êtes sûr que c'est OK (pas de/attention à l'utilisation de pointeurs sur des objets, les éléments sont suffisamment petits pour copier efficacement, etc.). Parfois, vous avez à penser ni à mesure des spécificités de votre situation, mais c'est un guide approximatif.

    • Ce qui signifie de grandes structures? Est-il un exemple d'une grande structure et une petite structure?
    • Comment pouvez-vous dire octets.Remplacez prend 80 octets de args sur amd64 ?
    • La signature est Replace(s, old, new []byte, n int) []byte; s, les vieux et les nouveaux sont les trois mots chacun (tranche en-têtes sont (ptr, len, cap)) et n int est un seul mot, donc 10 mots, qui, à huit octets/mot de 80 octets.
    • Comment définir les grandes structures? Comment grand est grand?
    • Aucune de mes sources (revue de code, commentaires, etc.) définir un seuil, alors j'ai décidé de dire que c'est un jugement d'appel, au lieu de faire un seuil maximum. Trois mots (comme une tranche) est presque toujours considéré comme pouvant être une valeur dans la stdlib. J'ai trouvé une occurrence d'un mot de cinq de la valeur récepteur tout à l'heure (texte/scanner.Position) mais je ne lis pas beaucoup plus dans ce (il est aussi passé comme un pointeur!). Absent des repères, etc., Je venais tout juste de faire ce qui lui paraît la plus commode pour des raisons de lisibilité.
    • Depuis le premier maillon de cette réponse: Si le récepteur est une grande structure ou un tableau, un pointeur récepteur est plus efficace. Comment grand est grand? Assumer, c'est l'équivalent de passer tous ses éléments comme des arguments de la méthode. Si cela semble trop grande, elle est aussi trop grand pour le récepteur.

    InformationsquelleAutor twotwotwo
  2. 10

    Trois raisons principales lorsque vous souhaitez utiliser la méthode de récepteurs que les pointeurs:

    1. "Première, et la plus importante, est la méthode de la nécessité de modifier le récepteur? Si c'est le cas, le récepteur doit être un pointeur."

    2. "Deuxième est la prise en compte de l'efficacité. Si le récepteur est grande, une grande struct par exemple, il sera beaucoup moins cher d'utiliser un pointeur récepteur."

    3. "Suivant est la cohérence. Si certaines des méthodes du type doit avoir pointeur de récepteurs, le reste doit trop, de sorte que la méthode d'ensemble est cohérent, indépendamment de la façon dont le type est utilisé"

    Référence : https://golang.org/doc/faq#methods_on_values_or_pointers

    Edit : une Autre chose importante est de connaître la véritable "type" que vous envoyez à la fonction. Le type peut être soit une valeur de type " ou "type de référence'.

    Même que les tranches et les cartes des actes comme des références, on peut vouloir les passer comme des pointeurs dans des scénarios tels que la modification de la longueur de la tranche dans la fonction.

    • Pour le 2, quelle est la fréquence de coupure? Comment puis-je savoir si mon struct est grand ou petit? Aussi, est-il une structure qui est assez petit tel qu'il est plus efficace d'utiliser une valeur plutôt que de pointeur (de sorte qu'il n'a pas à être référencé dans le tas)?
    • Je dirais que plus le nombre de champs et/ou des structures imbriquées à l'intérieur, plus la structure est. Je ne suis pas sûr si il est spécifique de coupure ou de manière standard de savoir quand une structure peut être qualifié de "grand" ou "grand". Si je suis en utilisant ou en créant une structure (struct), je voudrais savoir si sa petite ou grande, basé sur ce que j'ai dit ci-dessus. Mais c'est juste moi!.
    InformationsquelleAutor Santosh Pillai
  3. 1

    Cas où vous aurez généralement besoin de retourner un pointeur est lors de la construction d'un instance de certains avec ou ressource commune. Ceci est souvent réalisé par des fonctions préfixées avec New.

    Parce qu'ils représentent une instance spécifique de quelque chose et ils peuvent avoir besoin de coordonner certains d'activité, il ne fait pas beaucoup de sens pour générer, dupliqué, copié structures représentant la même ressource -- de sorte que le pointeur retourné agit comme la poignée de la ressource elle-même.

    Quelques exemples:

    Dans d'autres cas, les pointeurs sont retourné simplement parce que la structure peut être trop grand pour copier par défaut:

    Sinon, le retour des pointeurs directement pourraient être évités par une au lieu de retourner une copie d'une structure qui contient le pointeur à l'interne, mais peut-être que ce n'est pas considéré comme idiomatiques:

    • Implicite dans cette analyse est que, par défaut, les structures sont copiés par valeur (mais pas nécessairement leur indirected membres).
    InformationsquelleAutor nobar
  4. 0

    Si vous pouvez (par exemple, un non-ressource partagée qui n'a pas besoin d'être adopté comme référence), utilisez une valeur. Par les raisons suivantes:

    1. Votre code sera plus agréable et plus lisible, en évitant les opérateurs de pointeur null contrôles.
    2. Votre code sera plus en sécurité à l'encontre de Pointeur Null panique.
    3. Votre code sera souvent plus rapide: oui, plus vite! Pourquoi?

    Raison 1: vous allez allouer moins d'éléments dans la pile. Allocation/désallocation de la pile est immédiat, mais l'allocation/désallocation sur le Tas peut être très coûteux (moment de l'allocation + de collecte des ordures). Vous pouvez voir quelques chiffres de base ici: http://www.macias.info/entry/201802102230_go_values_vs_references.md

    Raison 2: surtout si vous stockez les valeurs de retour en tranches, vos objets de mémoire sera plus compact dans la mémoire: boucle une tranche où tous les éléments sont contigus est beaucoup plus rapide que l'itération d'une tranche où tous les éléments sont des pointeurs vers d'autres parties de la mémoire. Pas pour l'indirection étape, mais pour l'augmentation des défauts de cache.

    Mythe disjoncteur: un typique x86 ligne de cache de 64 octets. La plupart des structures sont plus petites que ça. Le temps de la copie d'une ligne de cache en mémoire est similaire à la copie d'un pointeur.

    Que si une partie critique de votre code est lent je voudrais essayer quelques micro-optimisation et de vérifier si l'utilisation de pointeurs améliore quelque peu la vitesse, au détriment de la lisibilité et de la mantainability.

    InformationsquelleAutor Mario