fonction pour allouer de la memoire

Version imprimable

Voila je voudrais faire une fonction qui prend en parametre un double pointeur et deux entier pour determiner les tailles:

Code:

1
2
3
4
5
6
7
8
9
10
11
 
void init_maillage(double **dT,int imax,int jmax)
{
	int i;
 
	dT=(double**)malloc(sizeof(double*)*imax);
	for(i=0;i<imax;i++){
		dT[i]=(double*)malloc(sizeof(double)*jmax);
	}
 
}

Mais ça marche pas :(

Pour donner plus de details:

Code:

1
2
3
4
5
6
 
typedef struct maillage_t{
	int Ns,Nt;
	double **sommet;
        double **triangle;
}maillage_t;

Code:

1
2
3
4
5
//ceci marche
maillage->sommet=(double**)malloc(sizeof(double*)*(maillage->Ns));
	for(i=0;i<maillage->Ns;i++){
		maillage->sommet[i]=(double*)malloc(sizeof(double)*2);
	}

merci

19/11/2009, 00h54
LittleWhite
Il faut un pointeur en plus.
Code:

1 2 3 4 5 6 7 8 9 10 11 void init_maillage(double ***dT,int imax,int jmax) { int i; *dT=(double**)malloc(sizeof(double*)*imax); for(i=0;i<imax;i++){ (*dT)[i]=(double*)malloc(sizeof(double)*jmax); } }
( Je sais pas si je vais réussir l'expliqué ).

C'est juste, parce que nous voulons modifié la valeur passé dans la fonction. Comme nous voulons un tableau à double dimension, pour avoir sa valeur en paramètres, il faut un pointeur sur celui ci. Sinon, on ne change pas la valeur à l'extérieur de la fonction d'initialisation, donc on perd de la mémoire ( fuite ).

( En mieux expliquer, le premier malloc, va changer la valeaur de Dt directement. Mais comme on le sais tous, pour récupéré une valeur avec un paramètre,il faut utiliser un pointeur. Du coup, pour avoir la bonne chose, il faut passer un pointeur sur un tableau à double dimension, car le malloc va modifier la valeur pointé ( et non le pointeur en lui même ) , donc on pourra récupéré notre tableau par la suite. )
19/11/2009, 03h21
haydens

Je ne comprend pas trop .... c'est compliqué :(
Mais du coup vu que le parametre est ***Dt il fau que je passe une adresse d'un double pointeur quand j'appelle la fonction par exemple:

int **p;
init_maillage(&p,4,7)

Un peu tordu quand meme
Merci beaucoup

Effectivement, il faut soit ajouter un niveau d'indirection supplémentaire, soit retourner l'adresse du pointeur, comme ci-dessous:

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
double ** init_maillage(int imax,int jmax)
{
    double **dT = NULL;
 
    dT = malloc(imax * sizeof *dT );
    /* -tc- Attention a toujours verifier la validite de l'adresse retournee
       par malloc() */
    if (dT != NULL)
    {
        int i;
        int err = 0;
 
        for (i = 0; err == 0 && i < imax; i++)
        {
            dT[i] = malloc(jmax * sizeof *dT[i]);
            if (dT[i] == NULL)
            {
                err = 1;
            }
        }
 
        if (err == 0)
        {
            /* -tc- Initialisation de dT */
        }
        else
        {
            /* -tc- Erreur d'allocation: on fait le menage */
            do
            {
                i--;
                free(dT[i]);
            }
            while (i > 0);
 
 
            free(dT), dT = NULL;
        }
    }
    else
    {
        /* -tc- Erreur: allocation de memoire impossible. La fonction retournera
           la valeur NULL */
    }
 
    return dT;
}

Voici un squellette pour l'utilisation de cette fonction:

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 <stdio.h>
#include <stdlib.h>
 
double ** init_maillage(int imax,int jmax)
{
    double **dT = NULL;
 
    dT = malloc(imax * sizeof *dT );
    /* -tc- Attention a toujours verifier la validite de l'adresse retournee
       par malloc() */
    if (dT != NULL)
    {
        int i;
        int err = 0;
 
        for (i = 0; err == 0 && i < imax; i++)
        {
            dT[i] = malloc(jmax * sizeof *dT[i]);
            if (dT[i] == NULL)
            {
                err = 1;
            }
        }
 
        if (err == 0)
        {
            /* -tc- Initialisation de dT */
        }
        else
        {
            /* -tc- Erreur d'allocation: on fait le menage */
            do
            {
                i--;
                free(dT[i]);
            }
            while (i > 0);
 
 
            free(dT), dT = NULL;
        }
    }
    else
    {
        /* -tc- Erreur: allocation de memoire impossible. La fonction retournera
           la valeur NULL */
    }
 
    return dT;
}
 
void detruire_maillage(double ***p_dT, int imax)
{
    if (p_dT != NULL && *p_dT != NULL)
    {
        double **dT = *p_dT;
        int i;
 
        for (i = 0; i < imax; i++)
        {
            free(dT[i]);
        }
        free(dT);
        *p_dT = NULL;
    }
}
 
int main(void)
{
    int err = 0;
 
    double **dT = init_maillage(4, 5);
    if (dT != NULL)
    {
        /* -tc- Suite du code ici */
 
        detruire_maillage(&dT, 4);
    }
    else
    {
        /* -tc- Erreur d'allocation */
        err = EXIT_FAILURE;
    }
 
    return err;
}

Thierry

19/11/2009, 20h17
haydens

Merci beaucoup je comprends mieux la :)