Comment éviter que les tableaux de taille variable ne se bloquent quand la mémoire est insuffisante?

Question

Avant les tableaux de longueur variable ont été pris en charge, je les allouer dynamiquement comme ceci:

int foo(size_t n) 
{ 
    int *arr = malloc(n * sizeof int); 
    if (!arr) return ENOMEM; /* not enough memory */ 
    . 
    . else do stuff with arr[] 
    . 
    free(arr); 
    return 0; 
} 

Avec des tableaux de longueur variable, je peux maintenant le faire paraître plus propre:

int bar(size_t n) 
{ 
    int arr[n]; 
    . 
    . do stuff with arr[] 
    . 
    return 0; 
} 

Mais maintenant je n'a pas de vérification "out of memory". En fait, le programme se bloque si n est trop grand.

Comment puis-je gracier gracieusement de la barre (n) si n est trop grand?

Answer 1

La situation est exactement inchangé par rapport à toutes les autres variables locales - une déclaration comme celle-ci:

int baz(void) 
{ 
    int arr[100000]; 
    . 
    . do stuff with arr[] 
    . 
    return 0; 
} 

a exactement le même problème. La "solution" est la même qu'elle l'a toujours été - ne pas recurrencer trop profondément, et ne pas allouer de très grandes structures de données avec une durée de stockage automatique (continuer à utiliser malloc() pour ces cas). La valeur de "très grand" dépend fortement de votre environnement. En d'autres termes, ne déclarez pas int array[n];, sauf si vous savez que n est limité à une valeur raisonnable, de sorte que vous auriez été heureux de déclarer un tableau de cette taille maximale comme un type ordinaire, non modifié de manière variable tableau.

(Oui, cela signifie que les tableaux de type variablement modifiés ne sont pas aussi utiles qu'ils apparaissent au début, car vous gagnez très peu en déclarant simplement le tableau à la taille maximale requise).

Answer 2

Vous pouvez les empêcher de se bloquer en ne les utilisant pas. :)

Sérieusement, il n'y a presque aucun moyen sûr d'utiliser des tableaux de longueur variable pour vous rendre la vie plus facile, sauf si vous avez des limites fortes sur la taille. D'autre part, vous pouvez les utiliser sous condition, de manière à ceci:

char vla_buf[n < 1000 ? n : 1]; 
char *buf = sizeof vla_buf < n ? malloc(n) : vla_buf; 
if (!buf) goto error; 
/* ... Do stuff with buf ... */ 
if (buf != vla_buf) free(buf); 

Bien que cela ressemble à la douleur inutile, il peut faire une énorme différence de performances, en particulier dans les applications threadées où de nombreux appels à malloc et free pourrait entraîner un conflit de verrouillage. (Un autre avantage notable de cette astuce est que vous pouvez soutenir les anciens compilateurs sans VLA en remplaçant simplement [n < 1000 ? n : 1] avec 1000, par exemple avec une macro.)

Un autre cas obscur où VLA peut être utile est dans les algorithmes récursifs où vous connaissez les Le nombre total d'entrées de tableau requises pour tous les niveaux de récursivité est limité par n, où n est suffisamment petit pour que vous soyez certain qu'il ne débordera pas la pile, mais où il peut y avoir jusqu'à n niveaux de récursivité et niveaux individuels qui sont épuisés à n éléments. Avant C99, la seule façon de gérer ce cas sans prendre l'espace de pile n^2 était d'utiliser malloc. Avec les VLA, vous pouvez résoudre entièrement le problème sur la pile. Gardez à l'esprit, ces cas où les VLA sont vraiment bénéfiques sont assez rares. Normalement, VLA est juste un moyen de vous tromper que la gestion de la mémoire est facile, jusqu'à ce que vous soyez un peu par les vulnérabilités qui en résultent (trivial-à-exploiter) que vous avez créé.:-)

Edit: Pour mieux répondre question originale OP:

#define MAX_VLA 10000 
int bar(size_t n) 
{ 
    int arr[n <= MAX_VLA ? n : 1]; 
    if (sizeof arr/sizeof *arr < n) return ENOMEM; 
    /* ... */ 
    return 0; 
} 

Answer 3

En réalité, il est extrêmement coûteux de vérifier les conditions de mémoire partout. La façon de traiter les données massives consiste à limiter la taille des données en définissant une limite de taille stricte à un point de contrôle unique et à échouer rapidement et avec élégance lorsque la limite est atteinte.

Ce que je viens de suggérer est simple et stupide. Mais c'est ce que fait chaque produit ordinaire (non scientifique ou spécial). Et c'est ce qui est normalement attendu par le client.