Discussion :

[haydens]

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

Code :

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

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 :

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

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

Code :

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

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

[LittleWhite]

Il faut un pointeur en plus.

Code :

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

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

[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

[Thierry Chappuis]

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

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

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

[haydens]

Merci beaucoup je comprends mieux la