Discussion :

[mach1]

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 :

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
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;
}

[Invité]

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

Essaye déjà de remplacer ca par

Code :

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

*tab = malloc (taille);

(pareil dans les tableaux 2D...)

Francois

[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.

[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

[mach1]

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

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
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.

[fregolo52]

Pour info,
Tes tests :

Code :

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

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é.

[mach1]

Ok, merci bien d'avoir pris le temps de me répondre.

[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...