Il s'agit d'une solution C très courante que j'utilise pour le problème qui pourrait être utile. Contrairement aux VLA, il ne fait face à aucun risque pratique de débordement de pile dans les cas pathologiques.
/// Used for frequent allocations where the common case generally allocates
/// a small amount of memory, at which point a heap allocation can be
/// avoided, but rare cases also need to be handled which may allocate a
/// substantial amount. Note that this structure is not safe to copy as
/// it could potentially invalidate the 'data' pointer. Its primary use
/// is just to allow the stack to be used in common cases.
struct FastMem
{
/// Stores raw bytes for fast access.
char fast_mem[512];
/// Points to 'fast_mem' if the data fits. Otherwise, it will point to a
/// dynamically allocated memory address.
void* data;
};
/// @return A pointer to a newly allocated memory block of the specified size.
/// If the memory fits in the specified fast memory structure, it will use that
/// instead of the heap.
void* fm_malloc(struct FastMem* mem, int size)
{
// Utilize the stack if the memory fits, otherwise malloc.
mem->data = (size < sizeof mem->fast_mem) ? mem->fast_mem: malloc(size);
return mem->data;
}
/// Frees the specified memory block if it has been allocated on the heap.
void fm_free(struct FastMem* mem)
{
// Free the memory if it was allocated dynamically with 'malloc'.
if (mem->data != mem->fast_mem)
free(mem->data);
mem->data = 0;
}
Pour l'utiliser dans votre cas:
struct FastMem fm;
// `result` will be allocated on the stack if 'len <= 512'.
char* result = fm_malloc(&fm, len);
// send result over network.
...
// this function will only do a heap deallocation if 'len > 512'.
fm_free(&fm, result);
Dans le cas ci-dessus, cela utilise la pile si la chaîne tient en 512 octets ou moins. Sinon, il utilise une allocation de tas. Cela peut être utile si, disons, 99% du temps, la chaîne tient en 512 octets ou moins. Cependant, disons qu'il y a un cas exotique fou que vous pourriez parfois avoir besoin de gérer lorsque la chaîne fait 32 kilo-octets où l'utilisateur s'est endormi sur son clavier ou quelque chose comme ça. Cela permet de gérer les deux situations sans problème.
La version actuelle que j'utilise dans la production a également sa propre version de reallocet callocet ainsi de suite, ainsi que des structures de données conformes au standard C ++ construit sur le même concept, mais j'extrait le minimum nécessaire pour illustrer le concept.
Il a la mise en garde qu'il est dangereux de copier et vous ne devez pas renvoyer les pointeurs alloués à travers lui (ils pourraient finir par être invalidés lorsque l' FastMeminstance est détruite). Il est destiné à être utilisé pour des cas simples dans la portée d'une fonction locale où vous seriez tenté de toujours utiliser la pile / VLA, sinon où certains cas rares pourraient provoquer des débordements de tampon / pile. Ce n'est pas un allocateur à usage général et ne doit pas être utilisé comme tel.
Je l'ai en fait créé il y a longtemps en réponse à une situation dans une base de code héritée utilisant C89 qu'une ancienne équipe pensait ne jamais arriver lorsqu'un utilisateur parviendrait à nommer un élément avec un nom de plus de 2047 caractères (peut-être s'est-il endormi sur son clavier ). Mes collègues ont en fait essayé d'augmenter la taille des tableaux alloués à divers endroits à 16384 en réponse, à quel point je pensais que cela devenait ridicule et échangeait simplement un plus grand risque de débordement de pile en échange d'un moindre risque de débordement de tampon. Cela a fourni une solution très facile à brancher pour corriger ces cas en ajoutant simplement quelques lignes de code. Cela a permis de gérer le cas commun très efficacement et d'utiliser toujours la pile sans ces rares cas fous qui exigeaient que le tas écrase le logiciel. Cependant, je' Je l'ai trouvé utile depuis lors, même après C99, car les VLA ne peuvent toujours pas nous protéger contre les débordements de pile. Celui-ci peut mais toujours des pools de la pile pour les petites demandes d'allocation.