allocation mémoire statique ou dynamique, sur le tas ou la pile
Bonjour,
Dans mes fonctions, j'ai constamment besoin d'allouer des zones mémoires de taille variable, au sens propre, c'est-à-dire qu'elle n'est pas prédéfinie mais connue uniquement lors de l'application.
D'abord, est-ce que vous considérez les 2 équivalences
alloc statique <==> sur la pile
alloc dynamique <==> sur le tas
comme correctes? Il me semble que c'est une erreur de conception. Si je comprends bien, historiquement il y avait bien un lien direct dans les deux cas, mais on peut attribuer cela à des limitations à la fois technologiques et du langage. Rien, d'alleurs, n'a jamais empêché de faire de l'allocation statique sur le tas. Et de nouveaux outils domme alloca permettent --à nouveau si je comprends bien-- de faire une allocation dynamique sur le pile. Ca vous semble tenir la route, comme point de vue?
D'autre part, il y a une confusion totale à propos des termes statique / dynamique d'une part, et variable / constant de l'autre. Pour une raison que je ne comprends pas on utilise très souvent dynamique/statique (= qui peut/ne peut pas changer) pour dire en fait constant/variable (= qui a toujours ou non la même valeur, à chaque application) ; ou alors pour dire les deux à la fois (*).
Dans le cas de l'allocation mémoire, ce n'est pour moi pas du tout la même chose de pouvoir allouer une taille variable (= qui dépend de directement de données variables, c'est à dire d'input), que de pouvoir allouer une taille dynamique (= qui peut changer en fonction de besoins actuels changeants). Qu'en pensez-vous?
Passons à des interrogations un tout petit peu moins philosophico-programmatiques:
Dans le cas où une zone mémoire doit être retournée à la fonction appelante, il me semble que l'allocation sur le tas via malloc et ses amis est nécessaire. Une allocation locale, sur la pile, serait perdue à la fin du bloc où elle a été allouée (==> segfault, si on de la chance). Je reformule ici des banalités sans doute triviales juste pour être sûr que je les pense bien et dans les bons termes. Merci de critiquer toute incorrection, ambiguité ou imprécision.
Il arrive aussi plus rarement qu'une zone mémoire variable ait une utilité purement locale. Je viens ainsi d'écrire l'équivalent d'une caténation, mais sur des éléments qui ne sont pas des char* : il me faut donc un tableau intermédiaire, de taille variable, où je stocke leur expression textuelle. La constitution de ce tableau permet au passage de caculer la taille finale du texte et donc d'allouer celui-ci (sur le tas, malloc) exactement et d'un seul coup. Où mettre le tableau intermédiaire, et comment? Il est donc de taille variable et d'ailleurs sans limite prédéfinie. Je vois les possibilités suivantes:
1. Sur la pile, en statique, surallloué avec une taille max dont l'usager est clairement prévenu. Mais quelle est la taille maxi? Comment sait-on jusqu'où la taille de la pile peut gonfler? (*)
2. Utiliser alloca, donc une taille variable mais sur la pile. Même question au niveau des limites de la pile.
3. Utiliser un tableau variable (VLA). Là, mon problème, c'est plutôt : où il est?
4. Sur le tas, via malloc.Envoyé par wikipedia [url
Je n'arrive pas bien à comprendre les avantages et inconvénients respectifs de chaque solution, sauf la première. Surtout, les avantages et inconvénients "différentiels", je veux dire les unes par rapport aux autres.
Qu'en pensez-vous?
Merci,
Denis
(*) Le cas typique étant le typage : quand on parle de typage statique, on veut généralement dire constant, c'est-à-dire qu'il est prédéfini lors de la conception (et explicitement dans le code ou par inférence de type) et donc constant lors de toute application. Parfois on veut aussi dire, el plus, statique, c'est-à-dire que le type ne change pas au cours d'une même application.
(Un langage dit "dynamique" permet les deux : typage variable et dynamique. Mais le typage variable est en fait bien plus caractéristique de ces langages, et c'est ce qui leur coûte très cher en temps et espace.)
En revanche, la terminologie du langage C pour les "variable-length arrays" (VLA) de C99 est tout-à-fait correcte : leur taille est "variable", mais pas "dynamic" --à ce que je sache.
(**) Je considère que le tas peut gonfler à l'infini, et que le jour où, sur l'ordi d'un usager, on atteint la limite physique dispo à l'instant, c'est pas mon problème : on crashe, et basta!
C'est différent pour la pile d'appels, j'ai l'impression qu'il est d ema responsabilité de bien la gérer, de pas y faire n'importe quoi.
Répondre avec citation
.
)
. Du moins je ne le fais pas si je sais que je risque d'approcher le Mo voir +.
. J'utilise toujours la documentation de la glib à chaque fois que j'utilise une de ses fonctions. Elle indique si le résultat doit être explicitement libéré ou non.
Partager