Allocation dynamique de mémoire

Version imprimable

Bonjour,
j'essaie de créer une fonction pour allouer dynamiquement des tableaux à une dimension et une autre pour allouer des tableaux à deux dimensions.
Toutefois, lorsque j'exécute mon programme, il plante c'est pourquoi je fais appel à votre aide.

CODE :

Code:

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
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
#include <stdio.h>
#include <stdlib.h>
 
void creerTableau1D(void **tab, int taille)
{
    *tab = malloc (sizeof (**tab) * taille);
 
    if(*tab == NULL)
        exit(EXIT_FAILURE);
}
 
 
 
void creerTableau2D(void ***tab, int base, int hauteur)
{
    int i = 0;
 
    *tab = malloc (sizeof (**tab) * base);
 
    if(*tab == NULL)
        exit(EXIT_FAILURE);
 
    for (i = 0; i < base; i++)
    {
        (*tab)[i] = malloc (sizeof (***tab) * hauteur);
 
        if((*tab)[i] == NULL)
            exit(EXIT_FAILURE);
    }
 
}
 
 
int main(void)
{
    int i = 0, j = 0;
    int **tab2D = NULL;
    int *tab1D = NULL;
 
    creerTableau1D(&tab1D, 10);
    creerTableau2D(&tab2D, 5, 10);
 
    for(i = 0; i < 10; i++)
    {
        tab1D[i] = 0;
    }
 
    for(j = 0; j < 10; j++)
    {
        for(i = 0; i < 5; i++)
        {
            tab2D[i][j] = 0;
        }
    }
 
    return 0;
}

17/05/2009, 21h48
Invité

Comme **tab est void, sizeof(**tab) ca ne va pas bien se passer...

Essaye déjà de remplacer ca par

Code:

*tab = malloc (taille);

(pareil dans les tableaux 2D...)

Francois
17/05/2009, 21h59
mach1

Oui tab est de type void mais il pointe vers un pointeur qui ne l'est pas lui.
Je me trompe ?
J'ai enlevé les sizeof mais le programme plante encore.
17/05/2009, 22h37
Invité

Si tu enlèves les sizeof(), tu dois multiplier les tailles que tu passes au malloc par la taille de ce que tu alloues (sinon, tu alloues 10 octets pour 10 int, qui font en fait 40 octets...).

Le problème est le suivant :

Si tu déclares le paramètre de ta fonction d'allocation comme void **tab
alors, pour ta fonction, **tab est un void et sizeof(**tab) va générer une erreur à la compilation... ou renvoyer 0 (parfois avec un warning), ce qui va faire planter ton tableau à la première utilisation (tu viens d'allouer un tableau de zéro octets...)

C'est pareil pour le sizeof(***tab) de la fonction 2D.

En revanche, dans la fonction 2D, sizeof(**tab) fonctionnera, car la taille d'un pointeur sur void est connue (c'est un entier).

POur éviter cela tu dois soit :

1- passer int **tab ou int ***tab, mais alors il te faut une fonction par type...
2- faire comme malloc fait dans la vraie vie, lui passer un pointeur sur void, mais une taille qui tient compte de la taille des objets que tu alloues : ici

taille*sizeof(int) pour la fonction 1D
hauteur*sizeof(int) pour la fonction 2D (et base*sizeof(*int), ou base, en conservant ton code original avec sizeof(**tab)*base...)

Francois

J'ai changé le code et ça a l'air de marcher :

Code:

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
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
#include <stdio.h>
#include <stdlib.h>
 
void creerTableau1D(void **tab, int taille, int nbOctetsParUnite)
{
    *tab = malloc (nbOctetsParUnite * taille);
 
    if(*tab == NULL)
        exit(EXIT_FAILURE);
}
 
 
 
void creerTableau2D(void ***tab, int base, int hauteur, int nbOctetsParUniteBase, int nbOctetsParUniteHauteur)
{
    int i = 0;
 
    *tab = malloc (nbOctetsParUniteBase * base);
 
    if(*tab == NULL)
        exit(EXIT_FAILURE);
 
    for (i = 0; i < base; i++)
    {
        (*tab)[i] = malloc (nbOctetsParUniteHauteur * hauteur);
 
        if((*tab)[i] == NULL)
            exit(EXIT_FAILURE);
    }
 
}
 
 
int main(void)
{
    int i = 0, j = 0;
    int **tab2D = NULL;
    int *tab1D = NULL;
 
    creerTableau1D(&tab1D, 10, sizeof(int));
    creerTableau2D(&tab2D, 5, 10, sizeof(int*), sizeof(int));
 
    for(i = 0; i < 10; i++)
    {
        tab1D[i] = 0;
    }
 
    for(j = 0; j < 10; j++)
    {
        for(i = 0; i < 5; i++)
        {
            tab2D[i][j] = 0;
        }
    }
 
    return 0;
}

J'espère que c'est correct.

18/05/2009, 10h21
fregolo52
Pour info,
Tes tests :
Code:

1 2 if(*tab == NULL) exit(EXIT_FAILURE);
ne servent à rien, malloc ne renvoie jamais NULL.
pour savoir si une allocation mémoire a achoué il faut tester le memset (que tu devrais faire apres un malloc).

J'ai déjà alloué 5Go sur un PC qui n'en n'avait qui 2, et malloc m'a renvoyé un pointeur non NULL alors qu'en réalité l'accolation a échoué.
18/05/2009, 13h30
mach1

Ok, merci bien d'avoir pris le temps de me répondre.
18/05/2009, 13h35
Médinoc
Prière de ne pas donner de fausses idées aux débutants.
1. Ça, c'est seulement sous nux avec l'allocation optimiste (une connerie monumentale) activée.
  Sur tout OS raisonnable (y compris Windows), tu n'as pas ce problème.
2. Sur tout OS raisonnable, malloc() renvoit NULL quand il n'y a plus de mémoire disponible.
3. Il n'y a aucun moyen standard de "tester" un memset pour faire ça. Mais en POSIX, il faut sans doute intercepter un certain signal...