tableau 2D et allocation dynamique

Version imprimable

Bonjour.
J'ai consulté la FAQ à ce sujet, et je voulais savoir s'il y un moyen de spécifier un type "tableau 2D". Est ce que la construction suivante est juste pour un constructeur ?
Code:

1 2 3 4 5 6 7 8 9 10 typedef double * ligne; typedef ligne * tableau2D; const long taille=10000; tableau2D tab; tab=malloc(sizeof(ligne)*taille) for(i=0;i<taille;i++) { tab[i]=malloc(sizeof(tableau2D)*taille) }
Désolé si c'est tout faux, je crois que je n'ai pas tout compris à la réponse dans la FAQ.

28/02/2007, 15h50
Médinoc
Presque, petite erreur sur le sizeof.
--> Évite le sizeof() sur les types.

[Code incorrect censuré]

TEST DU CODE EN COURS
- Ça compile
- Mais ça ne marchera pas bien (je n'ai même pas testé l'exécution, puisque j'ai vu des erreurs dans mon code).

Code:

1
2
3
4
5
6
7
8
9
10
11
typedef double *LIGNE;
typedef LIGNE *TABLEAU2D;
 
const long nblignes=100,nbcols=50;
TABLEAU2D tab;
 
if ((tab=(TABLEAU2D) malloc(nblignes*sizeof (LIGNE)))==NULL)
...
for (i=0;i<nblignes;++i)
 if ((tab[i]=(LIGNE) malloc(nbcols*sizeof (double)))==NULL)
  ...

Citation:
Envoyé par stephl
Code:

1 2 3 4 5 6 7 8 9 10 11 typedef double *LIGNE; typedef LIGNE *TABLEAU2D; const long nblignes=100,nbcols=50; TABLEAU2D tab; if ((tab=(TABLEAU2D) malloc(nblignes*sizeof (LIGNE)))==NULL) ... for (i=0;i<nblignes;++i) if ((tab[i]=(LIGNE) malloc(nbcols*sizeof (double)))==NULL) ...
Masquer des pointeurs :vomi:

Ce n'est que Force 6 sur l'échelle du goret... De plus, tu cast le retour du malloc (force 5)...

Lien

Jc

Mon code, testé et corrigé:

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
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
#include <stdlib.h>
#include <stdio.h>
 
#ifdef _DEBUG
#define DBG_PRINTF(a) printf a
#else
#define DBG_PRINTF(a)
#endif
 
/* Fonction d'allocation
   --------------------- */
double ** AllocTable2D(
 size_t taille1, /*[in] Nb de lignes */
 size_t taille2  /*[in] Nb de valeurs par ligne */
 )
{
    double ** ppValeurs;
 
    DBG_PRINTF((" Allocation d'un tableau de %u pointeurs...\n", (unsigned int)taille1));
    ppValeurs = malloc(sizeof(*ppValeurs)*taille1);
    if(ppValeurs != NULL)
    {
        size_t i;
        /* Initialiser tous les pointeurs à NULL
           Pour mieux libérer en cas d'échec */
        DBG_PRINTF((" Initialisation des pointeurs a NULL...\n"));
        for(i=0 ; i<taille1 ; ++i)
            ppValeurs[i] = NULL;
 
        /* Allocations des lignes */
        DBG_PRINTF((" Allocation de %u valeurs pour chaque pointeur...\n", (unsigned int)taille2));
        for(i=0 ; i<taille1 ; ++i)
        {
            double *pValeurs = malloc(sizeof(*pValeurs)*taille2);
            if(pValeurs==NULL)
                break;
            ppValeurs[i] = pValeurs;
        }
 
        /* Si echec, libérer les ressources */
        if(i < taille1)
        {
            size_t j;
            DBG_PRINTF((" Echec apres %u pointeurs. Destruction...\n", (unsigned int)i));
            /* Rappel: free(NULL) ne fait rien (inoffensif). */
            for(j=0 ; j<i ; ++j)
                free(ppValeurs[j]), ppValeurs[j]=NULL;
            free(ppValeurs), ppValeurs = NULL;
        }
    }/*if*/
    return ppValeurs;
}
 
/* Fonction de destruction
   ----------------------- */
void FreeTable2D(double **ppValeurs, size_t taille1)
{
    if(ppValeurs != NULL)
    {
        size_t i;
        for(i=0 ; i<taille1 ; ++i)
            free(ppValeurs[i]), ppValeurs[i]=NULL;
        free(ppValeurs), ppValeurs = NULL;
    }
}
 
/* Fonction de test
   ---------------- */
void TestArrayC(void)
{
    void const *pvPrintf;
    size_t const taille1 = 4200, taille2 = 14400;
    double **ppValeurs;
 
    puts("Allocation...");
    ppValeurs = AllocTable2D(taille1, taille2);
 
    pvPrintf = ppValeurs;
    printf("ppValeurs = %p\n", pvPrintf);
 
    puts("Destruction...");
    FreeTable2D(ppValeurs, taille1), ppValeurs=NULL;
}

28/02/2007, 16h14
stephl

Citation:

Envoyé par fearyourself

Masquer des pointeurs :vomi:

Ce n'est que Force 6 sur l'échelle du goret... De plus, tu cast le retour du malloc (force 5)...

Lien

Jc

Chacun sa façon de voir. Il suffit de savoir ce que l'on fait. Personnellement, je préfère caster le retour de malloc(): cela me force à vérifier que je ne fais pas n'importe quoi ;) .

@stephl: Au contraire, le cast du retour de malloc() peut masquer une erreur.

Quoi qu'il en soit, je préfère minimiser le nombre d'allocations pour ce genre de tableaux.
Je trouve ces fonctions plus simples:

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
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
#include <stdlib.h>
#include <stdio.h>
 
#ifdef _DEBUG
#define DBG_PRINTF(a) printf a
#else
#define DBG_PRINTF(a)
#endif
 
/* Autre fonction d'allocation
   --------------------------- */
double ** AutreAllocTable2D(
 size_t taille1, /*[in] Nb de lignes */
 size_t taille2  /*[in] Nb de valeurs par ligne */
 )
{
    double ** ppValeurs;
    size_t const taille1x2 = taille1*taille2;
    if(taille1x2 / taille2 != taille1)
        return NULL; /*Débordement des tailles*/
 
    DBG_PRINTF((" Allocation d'un tableau de %lu pointeurs...\n", (unsigned long)taille1));
    ppValeurs = malloc(sizeof(*ppValeurs)*taille1);
    if(ppValeurs != NULL)
    {
        double * pValeurs;
        DBG_PRINTF((" Allocation d'un tableau de %lu*%lu=%lu valeurs...\n",
         (unsigned long)taille1, (unsigned long)taille2, (unsigned long)taille1x2
         ));
        pValeurs = malloc(sizeof(*pValeurs)*taille1x2);
        if(pValeurs != NULL)
        {
            size_t i;
            /* Affecter tous les pointeurs */
            DBG_PRINTF((" Affectation des pointeurs...\n"));
            for(i=0 ; i<taille1 ; ++i)
                ppValeurs[i] = pValeurs + (i*taille2);
        }
        else
        {
            /* Echec de la seconde allocation, liberer la premiere */
            DBG_PRINTF((" Echec de la seconde allocation.\n"));
            free(ppValeurs), ppValeurs=NULL;
        }
    }/*if*/
    return ppValeurs;
}
 
/* Autre fonction de destruction
   ----------------------------- */
void AutreFreeTable2D(double **ppValeurs)
{
    if(ppValeurs != NULL)
    {
        free(ppValeurs[0]);
        free(ppValeurs);
    }
}
 
/* Fonction de test
   ---------------- */
void TestArrayC(void)
{
    void const *pvPrintf;
    size_t const taille1 = 4200, taille2 = 14400;
    double **ppValeurs1;
    double **ppValeurs2;
 
    puts("Allocation...");
    ppValeurs1 = AllocTable2D(taille1, taille2);
 
    pvPrintf = ppValeurs1;
    printf("ppValeurs1 = %p\n", pvPrintf);
 
    puts("Destruction...");
    FreeTable2D(ppValeurs1, taille1), ppValeurs1=NULL;
 
    puts("Allocation...");
    ppValeurs2 = AutreAllocTable2D(taille1, taille2);
 
    pvPrintf = ppValeurs2;
    printf("ppValeurs2 = %p\n", pvPrintf);
 
    puts("Destruction...");
    AutreFreeTable2D(ppValeurs2), ppValeurs2=NULL;
}

Edit: Une paire de petits schémas illustrant les différents concepts :
http://www.medinoc.fr/web/Programmat...auTableaux.png http://www.medinoc.fr/web/Programmation/Tableau2D.png
Et aussi la version sans les printf.
Et La version C++.

28/02/2007, 16h25
kromartien
Citation:
Envoyé par Médinoc

Presque, petite erreur sur le sizeof.
--> Évite le sizeof() sur les types.
...
TEST DU CODE EN COURS

Ça compile
Mais ça ne marche pas bien.
Ça ne marche pas bien signifie "segmentation fault" ou juste que ça rame à l'exécution ? (Je n'ai pas testé le code)

EDIT:vous construisez des fonctions plus vite que votre ombre.

(Digression : savez vous où je peux retrouver les flags de GCC pour un code ... conforme, enfin régulier, enfin qui veut dire quelque chose, enfin pas du code de goret quoi = "mode parano")
28/02/2007, 16h29
Médinoc

J'ai montré le défaut que je reproche aux autres :oops:
En fait, je ne suis même pas allé jusqu'à tester l'exécution de ce code, car j'ai vu que j'avais fait une erreur dedans.
Alors, je n'ai testé que le code corrigé.

Edit: D'ailleurs, ça montre bien qu'il est facile de se tromper pour les premières fonctions. Je préfère les secondes...

PS: http://emmanuel-delahaye.developpez....tm#cfg_compilo