Tableau a taille variable en C [Résolu]

Signaler
Messages postés
14
Date d'inscription
dimanche 5 avril 2009
Statut
Membre
Dernière intervention
5 avril 2009
-
Messages postés
1
Date d'inscription
dimanche 2 octobre 2005
Statut
Membre
Dernière intervention
30 novembre 2008
-
Voila, je cherhcer a programmer un tableau dont la taille serait définit par une variable qu'on pourrait choisir au debut du programme:

taille=0;
scanf ("%lf", &taille);
long x[taille];

et ensuite je rempli mon tableau.

Pourquoi faire une taille variable me direz vous?
Simplement car le but de la manip est de calculer une itération dont on pourrait choisir le pas.
Plus le pas est élevée, et plus la résolution va produire de valeures à stocker dans le tableau.

Ma question est donc existe t-il une commande permettant de définir un tableau à taille variable?
Si oui laquelle?

7 réponses

Messages postés
12303
Date d'inscription
mardi 10 février 2004
Statut
Modérateur
Dernière intervention
30 juillet 2012
38
!xtab c'est equivalent a xtab != NULL (donc a xtab != 0)

ensuite, sizeof est un operateur qui renvoie la taille d'un element. on peut effectuer cet operateur sur une variable ou sur un type.

les syntaxes sont differentes si on l'utilise sur une variable ou sur un type :

en effet, on peut faire :
sizeof variable
mais :
sizeof(type)

(pour les types, les parentheses sont obligatoires)
Messages postés
21042
Date d'inscription
jeudi 23 janvier 2003
Statut
Modérateur
Dernière intervention
21 août 2019
24
long *xtab;

xtab = (long*) malloc(taille * sizeof(long));
if(!xtab) ERREUR MEMOIRE;

ciao...
BruNews, MVP VC++
Messages postés
12303
Date d'inscription
mardi 10 février 2004
Statut
Modérateur
Dernière intervention
30 juillet 2012
38
salut

pourquoi taille n'est pas un size_t (enfin un int quoi...) ?

taille ne doit pas etre un double...

int taille;
scanf ("%d", &taille);

ensuite :
long x[taille];
ceci fonctionne en C99 (mais c'est pas un truc super propre...)


sinon, pour le C89, ou pour faire propre, comme le disait brunews :
long *xtab = malloc(taille * sizeof(long));
if(!xtab) ERREUR MEMOIRE;

(les casts, c'est vraiment utile ? c'est pas en CPP qu'on en a besoin pour pouvoir convertir un void* en long* ?)
Messages postés
21042
Date d'inscription
jeudi 23 janvier 2003
Statut
Modérateur
Dernière intervention
21 août 2019
24
En C ça compilerait sans cast (avec averto du compilo si correctement réglé) mais il faut prendre l'habitude du cast explicite, ça force à bien penser ce qu'on produit.

ciao...
BruNews, MVP VC++
Messages postés
14
Date d'inscription
dimanche 5 avril 2009
Statut
Membre
Dernière intervention
5 avril 2009

ça a l'air sympa vos idées, mais personnes ne pourrait me détailler un peu votre série de commandes, je suis débutant^^. Par exemple sizeof??? !xtab???

PS: dsl pour l'oubli de int pour la definition de taille^^.
Messages postés
21042
Date d'inscription
jeudi 23 janvier 2003
Statut
Modérateur
Dernière intervention
21 août 2019
24
Les bases d'un langage s'apprennent dans un bouquin.

ciao...
BruNews, MVP VC++
Messages postés
1
Date d'inscription
dimanche 2 octobre 2005
Statut
Membre
Dernière intervention
30 novembre 2008

Bonsoir,

Relativement au problème posé, je me permets de vous soumettre à votre étude un code, somme toute assez complet.

#include <stdio.h>
#include <stdlib.h>


/* Nous souhaitons gérer dynamiquement la taille d'un tableau unidimentionnel de type "long".
 * cette taille est le résultat d'une saisie clavier récupérée par un scanf
 */
 
int main(int argc, char * argv[], char * envp[])
{
    size_t uiTaille;
    int mainReturnValue = EXIT_SUCCESS;

     if (scanf("%u", &uiTaille) == 1)
     {
         /* La ligne de code suivant est somme toute la plus importante.
          * Elle déclare un pointeur constant, ce qui endigue toute tentative d'en modifier la valeur.
          * Ce pointeur correspond indirectement au nom du tableau dont nous avons besoin.
          * La fonction "malloc" demande au système de concéder, à ce programme, une partie de la RAM
          * dont il assure la gestion.
          * C'est dans cette RAM allouée que seront implantés les éléments du tableau.
          * L'argument indiquant un nombre d'octets, sachant que sizeof(long) fournit le nombre d'octets
          * occupés par un tel type, en le multipliant par le nombre d'éléments du tableau, cela contribue
          * à demander le juste nombre nécessaire
          */
      long * const aTab = malloc(sizeof(long) * uiTaille);
      if (aTab != NULL)
      {
          long index;


          /* Initialisation des éléments du tableau à zéro, par exemple
           */
          for (index = 0; index < uiTaille; index++)
              aTab[index] = 0;


          printf("Le premier élément du tableau est initialié à : %ld\n", aTab[0]);
          printf("Le dernier élément du tableau est initialié à : %ld\n", aTab[uiTaille -1 ]);


          /* La fonction "free" restitue au système la mémoire qu'il lui a concédée (temporairement)
           */
          free(aTab);


          putchar('\n');
      }
      else
      {
          puts("L'allocation dynamique de mémoire a échoué.");
       mainReturnValue = EXIT_FAILURE;
      }
  }
  else
  {
      puts("La saisie de la taille est incorrecte");
      mainReturnValue = EXIT_FAILURE;
  }


 return mainReturnValue;
}

   Cordialement.