Comment déclarer la taille d'un tableau au moment de l'exécution en C?

En gros, je veux le C de l'équivalent de ce (eh bien, juste la partie avec le tableau, je n'ai pas besoin de la classe et de traitement de chaîne et tout le reste):

public class Example
{
    static int[] foo;
    public static void main(String[] args)
    {
        int size = Integer.parseInt(args[0]);
        foo = new int[size]; //This part
    }
}

Pardon mon C l'ignorance. J'ai été corrompu par java 😉

On dirait que vous avez été corrompu par le C++;)

OriginalL'auteur Paul Wicks | 2009-03-15

  1. 11
    /* We include the following to get the prototypes for:
 * malloc -- allocates memory on the freestore
 * free   -- releases memory allocated via above
 * atoi   -- convert a C-style string to an integer
 * strtoul -- is strongly suggested though as a replacement
*/
#include <stdlib.h>
static int *foo;
int main(int argc, char *argv[]) {
    size_t size = atoi(argv[ 1 ]); /*argv[ 0 ] is the executable's name */
    foo = malloc(size * sizeof *foo); /* create an array of size `size` */
    if (foo) {  /* allocation succeeded */
      /* do something with foo */
      free(foo); /* release the memory */
    }
    return 0;
}

    Mise en garde:en improvisant des trucs, sans aucun contrôle d'erreur.

    Vous devez mentionner que "si (foo) gratuit(foo);" est le "garbage collection".
    Il n'y a pas de collecte des ordures en C. je mentirais 😉 Mais je n'ai mis dans certains commentaires.
    Je ne pense pas que foo doit être déclarée statique, le sens est différent avec java. Ici, nous voulons juste une variable globale.
    Quel est le problème avec statique? Il est mondial de fichier (champ d'application), avec une liaison interne et à mon avis beaucoup plus facile à comprendre pour l'OP que si j'avais écrit une version plus intelligente (il n'y aurait pas de variables globales). Aussi, c'est un hors-la-brassard version avec beaucoup laissé à désirer.
    Votre réponse est très ok. Je viens de dire que la déclaration d'foo comme un int * aurait été suffisant. En java statique est nécessaire de déclarer une variable qui sera instanciée qu'une seule fois, pas une fois par nouvel objet.

    OriginalL'auteur dirkgently

  2. 5

    En C, vous pouvez le faire avec cela, si vous ignorez le contrôle d'erreur:

    #include <stdlib.h>
static int *foo;

int main(int argc, char **argv)
{
     int size = atoi(argv[1]);
     foo = malloc(size * sizeof(*foo));
     ...
}

    Si vous ne voulez pas une variable globale et à l'aide de C99, vous pouvez faire:

    int main(int argc, char **argv)
{
    int size = atoi(argv[1]);
    int foo[size];
    ...
}

    Il utilise un VLA - longueur variable de tableau.

    OriginalL'auteur Jonathan Leffler

  3. 2

    Si vous avez besoin d'initialiser les données, vous pouvez utiliser calloc:

    int* arr = calloc (nb_elems, sizeof(int));
/* Do something with your array, then don't forget to release the memory */
free (arr);

    De cette façon, la mémoire allouée sera initialisé avec des zéros, ce qui peut être utile. Notez que vous pouvez utiliser n'importe quel type de données au lieu de int.

    OriginalL'auteur mirz

  4. 1

    Malheureusement, beaucoup de réponses à cette question, y compris les acceptée, sont corriger mais pas équivalent à l'OP de l'extrait de code. Rappelez-vous que operator new[] appelle le constructeur par défaut pour chaque élément du tableau. Pour POD types comme int qui n'ont pas de constructeur, ils sont par défaut-initialisé (lire: initialisé à zéro, voir §8.5 ¶5-7 de La Norme C++ ).

    J'ai juste échangé malloc (allouer de la mémoire non initialisée) pour calloc (allouer à zéro de la mémoire), donc l'équivalent pour le C++ extrait serait

    #include <stdlib.h>  /* atoi, calloc, free */

int main(int argc, char *argv[]) {
    size_t size = atoi(argv[1]);
    int *foo;

    /* allocate zeroed(!) memory for our array */
    foo = calloc(sizeof(*foo), size);
    if (foo) {
        /* do something with foo */

        free(foo); /* release the memory */
    }

    return 0;
}

    Désolé pour revivre cette vieille question, mais il juste ne se sent pas le droit de sortir sans un commentaire (que je n'ai pas le nécessaire rep) 😉

    OriginalL'auteur Jan

  5. 0
    int count = getHowManyINeed();
int *foo = malloc(count * sizeof(int));

    OriginalL'auteur Chuck