J'ai cherché pendant un certain temps mais aucune réponse concluante n'est donnée sur pourquoi les types de valeurs doivent être alloués sur la pile alors que les types de référence: mémoire dynamique ou objets doivent résider sur le tas. pourquoi ne peut-on pas attribuer la même chose sur la pile?Pourquoi la pile et le tas sont-ils tous les deux nécessaires pour l'allocation de mémoire?
Les variables locales sont allouées dans la pile. Si ce n'était pas le cas, vous ne pourriez pas avoir des variables pointant vers le tas lors de l'allocation de la mémoire de la variable. Vous pouvez allouer des choses dans la pile si vous le souhaitez, il suffit de créer localement un tampon assez important et de le gérer vous-même.
Ils peuvent être. En pratique, ils ne le sont pas parce que la pile est une ressource typiquement plus rare que le tas et que l'allocation de types de référence sur la pile peut l'épuiser rapidement. En outre, si une fonction renvoie des données allouées sur sa pile, il faudra copier la sémantique sur la partie de l'appelant ou risquer de retourner quelque chose qui sera écrasé par l'appel de fonction suivant.
Les types de valeurs, généralement des variables locales, peuvent être rapidement et facilement introduits et hors de portée grâce aux instructions de la machine native. La sémantique de la copie pour les types de valeur en retour est triviale car la plupart s'intègre dans les registres de la machine. Cela arrive souvent et devrait être aussi bon marché que possible.
Il n'est pas correct que les types de valeurs soient toujours présents dans la pile. Lire l'article de Jon Skeet sur le sujet:
Je comprends que le paradigme pile (allocations imbriquées/désallocations) ne peuvent pas gérer certains algorithmes qui nécessitent des durées de vie de l'objet non imbriquées.
de même que allocation statique paradigm ne peut pas gérer les appels de procédure récursifs. (par exemple calcul naïf de fibonacci (n) comme f (n-1) + f (n-2))
Je ne suis pas au courant d'un algorithme simple qui pourrait illustrer ce fait. toute suggestion serait appréciée :-)
Tout ce qu'une méthode met sur la pile disparaîtra à la fin de la méthode. Dans .net et Java, il serait parfaitement acceptable (en fait souhaitable) qu'un objet de classe disparaisse dès que la dernière référence à celui-ci a disparu, mais il serait fatal qu'un objet disparaisse alors que des références à ce dernier existent encore. Il n'est pas dans le cas général possible pour le compilateur de savoir, lorsqu'une méthode crée un objet, si des références à cet objet continueront d'exister après la sortie de la méthode. En l'absence d'une telle assurance, le seul moyen sûr d'allouer des objets de classe est de les stocker sur le tas. Incidemment, dans .net, un avantage majeur des types de valeur mutables est qu'ils peuvent être passés par référence sans abandonner le contrôle perpétuel sur eux. Si la classe 'foo', ou une de ses méthodes, a une structure 'boz' que l'une des méthodes de foo passe en référence à la méthode 'bar', il est possible pour une barre, ou les méthodes qu'elle appelle, de faire ce qu'elle veut boz 'jusqu'à ce qu'ils reviennent, mais une fois que' bar 'renvoie toutes les références qu'il a tenues à' boz 'sera parti. Cela conduit souvent à une sémantique beaucoup plus sûre et plus propre que les références partagées de façon promiscueusement utilisées pour les objets de classe.
Donc, fondamentalement, vous créez un tas géré personnalisé sur votre pile. ;) –
@bjarkef - hey, on fait ce qu'il faut faire :) –