De Taille Variable Tableaux vs calloc en C

Sur la discussion de la mémoire dynamique ici: "L'introduction à la C les Pointeurs et gestion Dynamique de la Mémoire"

L'auteur déclare:

Un bloc de mémoire, comme cela peut effectivement être utilisé comme un moyen plus souple de tableau. Cette approche est en fait beaucoup plus commun dans le monde réel C de programmes. Il est également de plus en plus prévisible et souple qu'une "variable de tableau de taille"

Le type de bloc de mémoire il parle en tant que telle:

const int size = 5;
int * array = calloc(size, sizeof(int));

et ensuite à l'aide d'un autre pointeur pour parcourir le tableau:

int * index = array;
for (i = 0; i < size; i++) {
    *index = 1; //or whatever value
    index++;
}

Ma question est de savoir comment cette méthode est mieux qu'un standard de taille variable array comme ceci?:

int array[variable];

ou dynamique:

char name[] = "Nick";

L'auteur n'a pas vraiment permis de beaucoup mieux comprendre pourquoi je préfère l'ancienne méthode de ce dernier. Ou plus précisément: Comment est-il plus "prévisible et flexible"?

Double Possible de malloced tableau de VS. de longueur variable array

OriginalL'auteur nmiller | 2009-01-15

  1. 10

    Si vous déclarez int array[variable] la mémoire est alloué sur la pile, ce qui n'est pas très bon pour le grand, relativement permanent des structures de données (tels que celui que vous pourriez vouloir aller-retour). Vous n'avez pas besoin pour libérer de la mémoire manuellement si vous utilisez la syntaxe de tableau car il est libéré lorsqu'elle est hors de portée. calloc sur l'autre main va allouer de la mémoire dynamiquement au moment de l'exécution sur le tas. Vous devrez gratuit-le vous-même dès que vous avez fini avec elle.

    gcc.gnu.org/onlinedocs/gcc/Variable-Length.html

    OriginalL'auteur Mehrdad Afshari

  2. 8

    Je suis d'accord avec ocdecio que c89 n'autorise pas

    int array[variable]

    c99 permet à certains types de variables et expressions à la taille de la matrice. Mais en plus de cela, les choses alloué avec malloc et la famille peut être redimensionnée à l'aide de realloc.

    OriginalL'auteur Evan Teran

  3. 3

    À l'aide de taille variable tableaux sur la pile comme une auto variable (au lieu du tas à l'aide de calloc/malloc/new/etc) n'est pas une mauvaise idée pour un processus qui va prendre du temps et aurez besoin de faire et de détruire beaucoup de petits tableaux. C'est parce que la pile est garanti de ne jamais devenir fragmenté, alors que la mémoire peut et va être fragmenté. Si vous écrivez un firmware ou un service qui doit fonctionner pendant des années sans s'arrêter, vous êtes presque interdit d'utiliser malloc ou de nouvelles.

    OriginalL'auteur Mark Lakata

  4. 2

    De longueur Variable automatique des tableaux sont autorisés dans la norme ISO C99, et comme une extension de GCC accepte en C90 mode et en C++.
    Donc, ne pas foget pour définir compilateur drapeau -std=c99 ou -std=gnu99. L'exemple suivant va travailler

    #include<stdio.h>

int main()
{
    int n;
    printf("\n\tEnter the number of digits: ");
    scanf("%d", &n);

    char str[n];
    for(int i=0; i < n; i++) {
        scanf("%s", &str[i]);
    }

    printf("\n\tThe entered digits are: %s", str);
return 0;
}

    Je garantie que 🙂

    OriginalL'auteur sakhabyn

  5. 0

    Parce que

    int array[variable];

    n'est pas valide en C standard, que vous ne pouvez définir la longueur d'un tableau avec une constante. (comme votre 

    char name[] = "Nick";

    exemple, ce qui n'est pas de longueur variable).

    En tant que tel, il est nécessaire d'utiliser un allocateur de mémoire comme calloc() si vous souhaitez créer un tableau d'une durée fondée sur une variable de programme.

    Il suffit de ne pas oublier de free ().

    Vrai, ce n'est pas de longueur variable. Je suppose que j'aurais dû mettre "dynamique". Comme le compilateur détermine combien doit être alloué.
    Peut-être -- mais "dynamique" implique tout de même au moment de l'exécution pour moi. Avec l'initialisation à partir d'une constante, la taille du tableau est déterminé à la compilation, pas au moment de l'exécution.
    Il est valable dans C99 pour un local (automatique) de la variable, il n'est pas valide externe de la déclaration de la variable (variable devrait être une constante de compilation).

    OriginalL'auteur HanClinto