Discussion :

[kadi09]

bonjour , je suis en charge de réaliser un programme de simulation de tri en utilisant différents structures de données, mais le problème que je doit utiliser un tableau d'allocation statique en demandant sa taille à l'utilisateur , comment je doit déclarer ce tableau et merci d'avance.

[mith06]

Bonjour,

Alors je ne suis pas sur de bien comprendre ton histoire, il y a deux possibilités:

Par définition la taille d'un tableau déclaré static doit être connue à la compilation. Donc ce que tu peux faire c'est déclarer une taille maximum, et contraindre l'utilisateur à cette taille maximum. Puis à toi de gérer le nombre d'éléments dans le tableau.

Sinon rien ne t’empêche de faire du malloc et du free sur un pointeur déclaré static. Mais je ne suis pas sur que c'est ce que tu voulais dire par tableau....

[esired]

Hello.
Pour utiliser un tableau dont la dimension n'est pas connue à l'avance, on utilise souvent un pointeur. Dans l'exemple, j'utilise un tableau de int. Vous pouvez utiliser le type de vos structures.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
 
#include <stdio.h>
#include <stdlib.h>
 
int main(int argc, char** argv) {
    int *p = NULL;
    int n;
 
    // Récuperer le nbre d'éléments su tableau
    scanf("%d", & n);    
 
    // Allouer le tableau
    p = malloc(n * sizeof(int));
    if (p != NULL) { // Il faut contrôler que le tableau est bien alloué
        // A partir d'ici, utiliser le pointeur comme un tableau ordinaire
        // p[0] pour le premier élément, p[n-1] pour le dernier
 
        // Libérer la mémoire, NE JAMAIS OUBLIER
        free(p);
    }
}

Pour plus d'infos, je vous recommande la lecture des cours de C.

[Sve@r]

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
 
#include <stdio.h>
#include <stdlib.h>
 
int main(int argc, char** argv) {
    int *p = NULL;
    int n;
 
    // Récuperer le nbre d'éléments su tableau
    scanf("%d", & n);    
 
    // Allouer le tableau
    p = malloc(n * sizeof(int));
    if (p != NULL) { // Il faut contrôler que le tableau est bien alloué
        // A partir d'ici, utiliser le pointeur comme un tableau ordinaire
        // p[0] pour le premier élément, p[n-1] pour le dernier
 
        // Libérer la mémoire, NE JAMAIS OUBLIER
        free(p);
    }
}

Salut
Pas mal ton exemple (+1). Toutefois si tu as 3 malloc à faire en cascade, avec le décalage des blocs de test tu vas te retrouver complètement à droite de ton écran pour programmer ensuite...

Regarde plutôt celui-là

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
 
#include <stdio.h>
#include <stdlib.h>
 
int main(int argc, char** argv) {
    int *p = NULL;
    int n;
 
    // Récuperer le nbre d'éléments su tableau
    scanf("%d", & n);    
 
    // Allouer le tableau
    p = malloc(n * sizeof(int));
    if (p == NULL) { // Il vaut mieux plutôt vérifier le pb
        fprintf(stderr, "Erreur alloc(%d) - %s\n", n, strerror(errno));
 
        // La fonction ne peut plus continuer son travail
        return -1;
    }
 
    // A partir d'ici, utiliser le pointeur comme un tableau ordinaire
    // p[0] pour le premier élément, p[n-1] pour le dernier
 
    // Libérer la mémoire, NE JAMAIS OUBLIER
    free(p);
}

[esired]

@Sve@r :

[Médinoc]

Le problème de l'exemple de Sve@r, c'est que quelqu'un peut alors être tenté de faire ceci:

Code incorrect :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
int main(int argc, char** argv) {
    int *p = NULL, *p2=NULL;
    int n;
 
    // Récuperer le nbre d'éléments su tableau
    scanf("%d", & n);    
 
    // Allouer le tableau
    p = malloc(n * sizeof(int));
    if (p == NULL) { // Il vaut mieux plutôt vérifier le pb
        fprintf(stderr, "Erreur alloc(%d) - %s\n", n, strerror(errno));
 
        // La fonction ne peut plus continuer son travail
        return -1;
    }
    p2 = malloc(n * sizeof(int));
    if (p2 == NULL) { // Il vaut mieux plutôt vérifier le pb
        fprintf(stderr, "Erreur alloc(%d) - %s\n", n, strerror(errno));
 
        // La fonction ne peut plus continuer son travail
        return -1; //Oups! fuite de mémoire!
    }
 
    // A partir d'ici, utiliser le pointeur comme un tableau ordinaire
    // p[0] pour le premier élément, p[n-1] pour le dernier
 
    // Libérer la mémoire, NE JAMAIS OUBLIER
    free(p);
    free(p2);
}

Et si tu ajoutes des allocations, il faut répéter dans chaque if(fail) le nettoyage de chaque allocation précédente...

Les trois moyens les plus courants d'éviter ceci sont:

• Le code initial, avec décalage à droite
• S'arranger pour gérer une seule ressource par fonction
• Un des rares usages "reconnus" du goto:
  

  Code incorrect :

  Sélectionner tout - Visualiser dans une fenêtre à part

  1
  2
  3
  4
  5
  6
  7
  8
  9
  10
  11
  12
  13
  14
  15
  16
  17
  18
  19
  20
  21
  22
  23
  24
  25
  26
  27
  28
  29
  30
  31
  32
  33
  34
  35
  int main(int argc, char** argv) {
      int ret = -1;
      int *p = NULL, *p2=NULL;
      int n;
   
      // Récuperer le nbre d'éléments su tableau
      scanf("%d", & n);    
   
      // Allouer le tableau
      p = malloc(n * sizeof(int));
      if (p == NULL) { // Il vaut mieux plutôt vérifier le pb
          fprintf(stderr, "Erreur alloc(%d) - %s\n", n, strerror(errno));
   
          // La fonction ne peut plus continuer son travail
          goto cleanup;
      }
      p2 = malloc(n * sizeof(int));
      if (p2 == NULL) { // Il vaut mieux plutôt vérifier le pb
          fprintf(stderr, "Erreur alloc(%d) - %s\n", n, strerror(errno));
   
          // La fonction ne peut plus continuer son travail
          goto cleanup;
      }
   
      // A partir d'ici, utiliser le pointeur comme un tableau ordinaire
      // p[0] pour le premier élément, p[n-1] pour le dernier
   
     ret = 0;
   
      // Libérer la mémoire, NE JAMAIS OUBLIER
  cleanup:
      free(p);
      free(p2);
      return ret;
  }