C++ Comment allouer de la mémoire dynamiquement sur la pile?

Est-il un moyen pour allouer de la mémoire sur pile au lieu de tas? Je ne peux pas trouver un bon livre sur ce, quelqu'un ici a une idée?

  • Si vous voulez contrôler où un std::string ou std::vector alloue de la mémoire, cochez cette question: stackoverflow.com/questions/354442/...
  • rapidement allouer/libre temporaire de l'espace de travail?
  • Butterworth Exemple: vous devez allouer un certain montant variable de l'espace pour un tampon temporaire pendant que vous trier les sommets en fonction de la profondeur. Les sommets venir de l'exécution des données, de sorte que vous ne connaissez pas à l'avance combien vous aurez. Aussi, vous disposez d'un budget de 2 microsecondes pour l'ensemble de la fonction, et sur votre plate-forme de malloc() coûts de 1 microseconde.
  • Donc, il suffit de créer des objets locaux comme d'habitude - pas besoin d'installations spéciales.
  • Je ne pense pas que vous pouvez mettre en œuvre un allocateur qui utilise alloca. La mémoire allouée ne peut être utilisé à l'intérieur de la fonction qui alloue, de sorte que le tampon ne peut pas être retourné à partir de l'allocateur!
  • et si la fonction a besoin d'un petit, mais variable, le nombre d'objets temporaires? Vous pouvez utiliser un vector, mais si la fonction est appelée dans une boucle serrée, ce serait cool si la mémoire peut être rapidement allouée et libéré sans se soucier de la fragmentation.
  • La accepté de répondre à cette question n'implique pas alloca.
  • ce que l'OP a demandé implique nécessairement alloca.
  • Alors allouer un petit, mais le fixe, le nombre d'objets sur la pile. Si nous ne savons pas la limite supérieure, alloca va souffler de toute façon.
  • Il y a beaucoup de questions sur StackOverflow où la question posée n'est pas ce que l'interlocuteur réellement nécessaire.
  • bien sûr, mais qui introduit un supplément de nombre magique dans le code, et à la limite varie en fonction de la machine, les drapeaux de compilation, etc. (tout ce qui peut influencer la taille de la pile). Si je cultive les taille de la pile, j'aurais maintenant besoin de changer les 2 ensembles de paramètres: la taille de la pile et la limite codée en dur pour ma fonction.
  • std::queue et la récursivité peut-être en tant que cet objet est conçu pour être rapide continue d'allocation. Remarque en C++ new et delete sont utilisés pour l'allocation de tas peut-être cela devrait être ré-étiquetés comme C.
  • alloca est largement utilisé dans Microsoft Windows, pour chaîne temporaire de zones tampons pour la traduction entre UTF-16 et Windows ANSI.
  • J'ai été à la programmation Windows depuis la version 2.0 et ne l'ai jamais utilisé, ou vu utilisé.,
  • Je suppose que tous ces appels sont cachés dans les versions ANSI de la Win32API, puisque le noyau traite uniquement les versions Unicode.
  • André dit. En outre, pour votre propre usage, je me souviens de MFC et ATL définir un groupe de macros que le paquet de la allocaappels. Je peux regarder si tu veux, mais depuis que je sais que vous êtes assez bon, je ne perds pas de temps à ça pour le moment. Cheers,

InformationsquelleAutor Mark | 2011-06-13
  1. 38

    Utilisation alloca() (parfois appelé _alloca() ou _malloca() ), mais être très prudent à ce sujet — il libère sa mémoire lorsque vous quittez une fonction, pas quand vous sortez de la portée, de sorte que vous allez vite exploser si vous l'utilisez à l'intérieur d'une boucle.

    Par exemple, si vous avez une fonction comme

    int foo( int nDataSize, int iterations ) 
{
   for ( int i = 0; i < iterations ; ++i )
   {
      char *bytes = alloca( nDataSize );
      //the memory above IS NOT FREED when we pass the brace below!
   } 
   return 0;
}  //alloca() memory only gets freed here

    Puis l'alloca() va allouer un supplémentaires nDataSize octets chaque passage dans la boucle. Aucun des alloca() octets être libéré jusqu'à ce que vous êtes de retour de la fonction. Donc, si vous avez un nDataSize de 1024 et un iterations de 8, vous allez allouer de 8 kilo-octets avant de retourner. Si vous avez un nDataSize= 65536 et iterations = 32768, vous allez allouer un total de 65536×32768=2,147,483,648 octets, presque certainement le soufflage de votre pile et de provoquer un incident.

    anecdote: Vous pouvez facilement avoir des ennuis si vous écrivez passé la fin de la mémoire tampon, surtout si vous passez le tampon dans une autre fonction, et que la sous-fonction a la mauvaise idée au sujet de la mémoire tampon de longueur. Une fois, j'ai fixé un plutôt amusant bug où nous avons été à l'aide de alloca() pour créer de stockage temporaire pour le rendu d'une police TrueType glyphe avant de l'envoyer à la mémoire GPU. Notre bibliothèque de polices n'ai pas de compte pour les diacritiques dans le suédois Å personnage lors du calcul de la glyphe de tailles, de sorte qu'il nous a dit de nous allouer n octets pour stocker la glyphe avant le rendu, et puis effectivement rendu n+128 octets. Le supplément de 128 octets écrit dans la pile d'appel, écraser l'adresse de retour et d'induire un vraiment douloureux non déterministe crash!

    • Butterworth l'Une des nombreuses raisons pour lesquelles nous n'avons pas l'utiliser C++ Standard dans le développement embarqué. =P
    • que faire si je l'utilise à l'intérieur d'une fonction récursive? Existe-il des effets secondaires? Aussi je ne comprends pas que la dernière partie est très bien, "...exploser si vous l'utilisez à l'intérieur d'une boucle". Mais une boucle est toujours à l'intérieur d'une fonction à droite?
    • Si vous exécutez alloca dans une boucle, il va allouer plus de mémoire à chaque itération, mais refuse de le libérer de la mémoire, jusqu'à ce que vous êtes de retour de la fonction (alors qu'un conteneur comme std::vector locale à la boucle sera libéré à la fin de la boucle de la portée).
    • vous pouvez l'utiliser dans la boucle récursive. dans la normale de la boucle, il ne sera pas libérer jusqu'à ce que la fonction retourne afin de produire un débordement de pile, mais dans la boucle récursive, il sera effacé à chaque itération.
    • si la fonction est nulle?
    • Eh bien, s'arrêter et de réfléchir. Qu'est-ce que alloca() faire, et comment le type de retour d'une fonction touchent?
    • Je ne pense pas que cela fait une différence.
    • Vous êtes correct.
    • Le lien est rompu et je veux les lire sur votre bug!

    InformationsquelleAutor Crashworks
  2. 5

    Puisque c'est marqué, C++, généralement, il suffit de déclarer les objets dont vous avez besoin dans le domaine approprié. Ils sont allouées sur la pile, et la garantie d'être libéré sur le champ de sortie. C'est RAII, et une critique avantage du C++ sur C. Pas de mallocs ou news, et surtout pas de allocas, nécessaire.

    • Ici, le problème est que de nombreux objets en C++ allouer de la mémoire pour eux-mêmes.
    • Lynx - bien sûr. Dans ce scénario, vous allouer un tel objet graphique sur la pile si?
    • Vous pouvez appeler une fonction que remplit dans un vecteur. Vous pourriez avoir besoin d'une chaîne de caractères. Vous pouvez avoir besoin de ces choses pour être très rapide et thread-safe. Si vous n'avez pas besoin de ces choses pour vivre au-delà de la fonction, puis de la pile de stockage est exactement le bon endroit.
    • pour des applications spécialisées, je peux voir que cela. Je pense que si l'OP a précisé pourquoi il y a un besoin perçu pour cela, je serais plus facile de les convaincre. Dans la plupart des cas, de mon point de vue est qu'il n'est pas nécessaire.
    • Je travaille principalement sur des environements et souvent mon utilisation de mémoire dans la mémoire allouée est considérablement limitée.
    • a noté. Si l'OP a ces contraintes, alors les choses peuvent être plus compliquées pour eux.

    InformationsquelleAutor Steve Townsend
  3. 3

    Vous pouvez déclarer un local char[1024] ou quel que soit le nombre d'octets que vous souhaitez (jusqu'à un certain point), puis prendre l'adresse du local pour un pointeur vers ce bloc de mémoire sur la pile. Pas exactement dynamique, mais vous pouvez envelopper ce mémoire avec votre propre gestionnaire de mémoire si vous le souhaitez.

    • Ce doit être la deuxième meilleure réponse à cette question spécifique si ce n'est la accepté de répondre. C'est propre et simple, à la différence de la _alloca réponse.
    • simple et mal parce que la question porte spécifiquement sur la dynamique (non statique) allocation de pile.
    InformationsquelleAutor DuckMaestro
  4. 2

    Article discutant sur l'allocation dynamique de la mémoire

    Nous pouvons allouer de longueur variable espace de façon dynamique sur la pile de la mémoire par
    à l'aide de la fonction
    _alloca. Cette fonction alloue de la mémoire de la pile du programme. Elle prend simplement le nombre d'octets à allouer et de retour void* à la
    l'espace alloué comme malloc appel. Ce mémoire allouée sera
    libéré automatiquement sur la sortie de la fonction.

    De sorte qu'il n'a pas besoin d'être libéré de manière explicite. On doit garder à l'esprit à propos de
    la taille d'allocation ici, comme l'exception de dépassement de pile peut se produire. Pile
    dépassement de la gestion des exceptions peuvent être utilisés pour de tels appels. En cas de
    débordement de la pile d'exception que l'on peut utiliser _resetstkoflw() pour le restaurer
    retour.

    Donc notre nouveau code avec _alloca serait :

    int NewFunctionA()
{
   char* pszLineBuffer = (char*) _alloca(1024*sizeof(char));
    …..
  //Program logic
     ….
  //no need to free szLineBuffer
  return 1;
}
    • Bienvenue DONC! Envisagez d'indiquer les bits les plus importants dans votre réponse, parce que des liens peuvent pourrir.
    • Salut, bienvenue DONC! Normalement une réponse seulement pointant vers une autre réponse n'est pas considéré comme une réponse. voir meta.stackexchange.com/a/118694 pour larification 😉
    • Si alloca est une manière de faire, il y a juste quelques inconvénients qui en fait une mauvaise pratique. Veuillez vous reporter à la discussion ici; stackoverflow.com/a/1018865/83005
    InformationsquelleAutor Sammy
  5. 1

    Si le C++ permet l'utilisation de (non statique) const valeurs limites du tableau, il sera plus facile.

    Pour l'instant, le meilleur moyen que je connaisse est via la récursivité. Il y a toutes sortes de trucs astucieux qui peut être fait, mais le plus simple que je connaisse est à votre routine de déclarer une taille fixe de tableau, et de le remplir et de fonctionner sur ce qu'il a fait. Quand c'est fait, si il a besoin de plus d'espace à la fin, il appelle lui-même.

    • Quelle question avez-vous répondu?
    • Dire quoi? C++ t permet de const valeurs limites du tableau (si par là tu veux dire la taille des matrices).
    • Neil Butterworth - lol, N'est ce pas? J'ai appris sur VC6, donc parfois j'ai frappé un "fait" qui n'est pas vraiment vrai. Ainsi, vous pouvez par exemple: lire un "tableau de taille" partir d'un fichier dans un size_t const et ensuite l'utiliser comme un tableau de la taille de l'index?
    • Évidemment pas, que vous ne pouvez pas lire sur un objet constant.
    • non, vous ne pouvez pas. Si pense que Neil compris static const où vous signifiait local const comme dans void f(const int n) { ... }.
    • Pour être clair, j'ai compris const int N = 42; char a[N];
    • Caron - Exactement. Je ne l'appelez pas "évident" que ce soit. Ada permet de faire cette chose exacte avec aucun scrupule que ce soit. Peut-être il ya une raison pourquoi le fait de permettre la même chose serait dommageable en C++, mais de mon point de vue, il apparaît une limitation arbitraire de la langue. Jusqu'changé, la seule façon standard autour d'elle je sais, c'est pour rendre le problème modulaire et utiliser la récursivité.
    • ...mis à jour le texte de (espérons-le) de le rendre plus clair pour Neil et autres.
    • Il ne va pas changer - le Comité des Normes & C++ de la communauté sont violemment opposés, que j'ai à dire, beaucoup de C des utilisateurs.
    • Butterworth - la Honte, mais je suis sûr qu'ils ont leurs raisons.
    • Il est impossible de normaliser les alloca sans exiger de toutes les implémentations d'avoir une pile. Si elle n'est pas garanti pour être pile juste inutile, et nous pouvons tous utiliser std::vector à la place.
    • Je ne suis pas sûr à ce sujet. C99 a réussi à standardiser les variables de la matrice de l'allocation sur la pile. Le problème n'est pas que vous ne pouvez pas le standardiser, mais que c'est une mauvaise idée.
    • Je ne peux même pas trouver le mot "pile" dans le standard C99, alors, comment savons-nous?
    • Ok, je parlais de soutien pour l'allocation automatique de int a[n]; où n est variable au moment de l'exécution. Et comme j'aime standardese et de pédantisme autant que la prochaine personne, je suppose que tu savais ce que je voulais dire 🙂
    • Je doute de savoir ce que tu veux dire, mais mon point est que VLAs sont moins utiles en C++ si ils se comportent comme un std::vector de toute façon. Être un avantage, nous avons besoin de savoir qu'ils ont un avantage de performance.
    • Lol. Ce doit être à peu près les plus controversés de la réponse sans voix " de toute façon jamais. Il devrait y avoir un badge de quelque sorte pour cela. 🙂

    InformationsquelleAutor T.E.D.
  6. 1

    Vous pouvez utiliser le BDE de la bibliothèque C++, par exemple

    const int BUFFER_SIZE = 1024;
char      buffer[BUFFER_SIZE];

bdlma::BufferedSequentialAllocator allocator(buffer, BUFFER_SIZE);
bsl::vector<int>                   dataVector(&allocator);

dataVector.resize(50);

    BDE fournit des allocateur options, ainsi que des collections comme bsl::vector qui peut utiliser polymorphes allocateurs sans changer le type de conteneur.

    Vous pourriez aussi envisager d':

    InformationsquelleAutor JDiMatteo