Discussion :

[damien77]

Bonjour j'aimerais savoir quelque chose en ce qui concerne les pointeurs.

Code :

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

1
2
3
4
5
6
 
int *a, *b ;
a = (int*)malloc(50*sizeof(int));
b = a ;
...
free(a) ;

Doit-je faire aussi un free(b) ou pas besoin ?

merci

[salseropom]

non, mais tu devrais faire un

Code :

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

1
2
3
 
b=NULL;
a=NULL;

après free, pense à remettre ton pointeur à NULL (idem après un fclose())

[Thierry Chappuis]

Tu dois faire autant d'appels à free() que tu as fait d'appels à malloc(). Dans ton code, les pointeurs a et b pointent sur le même espace mémoire. Une fois ce dernier libéré, l'adresse contenue dans les deux variables devient invalide. C'est pourquoi, comme l'a rapellé salseropom, il est fortement conseillé d'affecter aux deux pointeurs la valeur NULL (qui a l'avantage d'être une adresse invalide testable).

Au passage, il n'est pas nécessaire (voir même déconseillé) de convertir explicitement la valeur retournée par malloc en un pointeur sur int. De plus, il faut toujours tester la valeur retournée par malloc(). Même dans un snippet, j'écris toujours au moins:

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
int *a = NULL;
int *b = NULL;
 
/* L'écriture suivante facilite la maintenance part rapport à malloc(50 * sizeof(int)); */
a = malloc(50 * sizeof *a);
if (a != NULL)
{
    b = a ;
    /* ... */
    free(a), a = NULL, b = NULL;
}
else
{
    /* traiter convenablement l'erreur l'allocation memoire */
}

Thierry

[damien77]

D'accord. merci
Donc le code correct serais :

Code :

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

1
2
3
4
5
6
7
8
 
int *a,*b ;
a = (int*)malloc(sizeof(int)*50);
b = a;
   ... // manipulation de b et de a. avec b qui pointe toujours sur a.
free(a); // je libère a.
a = NULL ;
b = NULL ;

Par contre je voulais savoir si il était possible d'allouer de la mémoire via une fonction sans faire un retour :

int *taille(int n)
{
return (int *)malloc(sizeof(int)*50);
}

Peut-on faire un truc du genre :

taille(int **tab,int n)
{
*tab = (int *)malloc(sizeof(int)*50);
}

[Thierry Chappuis]

D'accord. merci
Donc le code correct serais :

Code :

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

1
2
3
4
5
6
7
8
 
int *a,*b ;
a = (int*)malloc(sizeof(int)*50);
b = a;
   ... // manipulation de b et de a. avec b qui pointe toujours sur a.
free(a); // je libère a.
a = NULL ;
b = NULL ;

Non, le code correct est celui que j'ai donné.

Thierry

[damien77]

désolé, nous avons postez en même temps, j'ai pas vue ta réponse...
Sinon pour la 2nd question ?

[Emmanuel Delahaye]

D'accord. merci
Donc le code correct serais :

Code :

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

1
2
3
4
5
6
7
8
 
int *a,*b ;
a = (int*)malloc(sizeof(int)*50);
b = a;
   ... // manipulation de b et de a. avec b qui pointe toujours sur a.
free(a); // je libère a.
a = NULL ;
b = NULL ;

Genre têtu, hein ? On te dit que le cast est inutile en C.

http://emmanuel-delahaye.developpez....tes.htm#malloc

Par contre je voulais savoir si il était possible d'allouer de la mémoire via une fonction sans faire un retour :

int *taille(int n)
{
return (int *)malloc(sizeof(int)*50);
}

Oui, mais le code est plus complexe du fait des indirectins...

Peut-on faire un truc du genre :

taille(int **tab,int n)
{
*tab = (int *)malloc(sizeof(int)*50);
}

Oui, mais il faut vérifier si tab est <> NULL avant de l'utiliser...

Encore une fois, le cast est inutile.

[Thierry Chappuis]

Peut-on faire un truc du genre :

taille(int **tab,int n)
{
*tab = (int *)malloc(sizeof(int)*50);
}

Oui. Il faut s'assurer au préalable que tab n'est pas NULL. Par ailleurs, le prototype de ta fonction n'est pas correct. Tu dois préciser le type de la valeur retournée. Si elle ne retourne rien, tu dois l'indiquer par void. Personnellement, je préfère dans ce cas retourner un code d'erreur:

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
/* Cette fonction alloue de la memoire. La fonction appellante est 
    responsable de sa liberation*/
int taille(int **tab, int n)
{
    err = 0;
    if (tab != NULL)
    {
        *tab = malloc(n * sizeof **tab);
        if (*tab != NULL)
        { 
            /* Suite du code ... */
        }
        else
        {
            /* Erreur d'allocation memoire */
            err = 2;
        }
    }
    else
    {
        /* Erreur d'argument */
        err = 1;
    }
    return err;
}

Thierry

[damien77]

Désolé pour le cast une vieille habitude...
D'accord, je penserais à faire les tests la fois prochaine ...

&tab = adresse de la variable.
tab = donne l'adresse du pointeur qui pointe sur le tableau
*tab = adresse du tableau
**tab = valeur du 1er élément du tableau

Existe-il d'autre cas d'utilisation de cette notation assez barbare ?

[Médinoc]

Oui, certains cas de tableau à deux dimensions alloués dynamiquement.
Des tableaux de ce genre-là, notamment :
http://www.developpez.net/forums/sho...3&postcount=14