Discussion :

[xc78370]

Bonjour !

J'effectue des tests sur l'allocation memeoire...

Dans une fonction,je déclare un char *.
Je passe ce pointeur à une fonction qui se charge d'allouer la memoire. En retour de la fonction, j'ai une erreur lorsque je fais un memeset sur ce pointeur ! Je ne comprends pas pourquoi ?

Voila mon 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
 
void modifalloc(char *pointeur)
{
 
   pointeur = (char *)malloc(10*sizeof(char));
 
}
 
void essai(void)
{
char *sztoto;
 
   modifalloc(sztoto);
   memset(sztoto, '*', 10);
 
   free(sztoto);
 
}

Merci de votre aide.

[crocodilex]

Tu t'y prends mal. En C, le passage de paramètre se fait par recopie de valeur. Donc forcement, ca ne peut pas marcher.
Essayes comme cela :

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
 
char *modifalloc(void)
{
   char *pointeur = NULL;
   pointeur = malloc(10);
   /* Faut egalement tester le retour de malloc */
 
  return (pointeur);
}
 
void essai(void)
{
   char *sztoto;
   sztoto = modifalloc();
   [...]
   free(sztoto);
}

[xc78370]

Quel est le probleme dans mon cas ?
Cela veut-il dire que l'adresse que je passe est parametre est recopiée par l'adresse fournie par malloc ? (Ais-je bien compris ?)
Je comprends ce que tu as fais... Cependant dans le cas ou 2 variables sont à prendre en compte, je ne pourrai pas utiliser cette méthode !

J'avais une autre question !
J'ai effectué mon free a la fin de ma fonction mere... Je me demandais si cela étais correct, dans le sens ou la taille de ma variable avait changée !!! Et en cherchant plus loin, est-il possible de ne pas faire le free, puisque la variable est déclarée dans la fonction, elle ser liberee à la sortie ???

Merci de ton aide crocodilex...

[Thierry Chappuis]

Salut,


Tu peux également faire:

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
 
#include <string.h>
#include <stdio.h>
#include <stdlib.h>
 
/* -TC- Dans ton cas, l'adresse contenue dans pointeur est passée par valeur. 
Si tu modifie pointeur, la valeur de sztoto n'est pas modifiée. Procéder comme suit: (ou comme crocodilex) */
void modifalloc(char **pointeur)
{
    /* -TC- Pas conseillé de caster le retour de malloc */
   *pointeur = malloc(10*sizeof(**pointeur));
    strncpy(*pointeur, "Salut", 10);
 
}
 
void essai(void)
{
   char *sztoto;
   /* -TC- Tu dois maintenant passer l'adresse de sztoto */
   modifalloc(&sztoto);
   puts(sztoto);
 
   free(sztoto), sztoto = NULL;
 
}

[Thierry Chappuis]

Quel est le probleme dans mon cas ?
Cela veut-il dire que l'adresse que je passe est parametre est recopiée par l'adresse fournie par malloc ? (Ais-je bien compris ?)
Je comprends ce que tu as fais... Cependant dans le cas ou 2 variables sont à prendre en compte, je ne pourrai pas utiliser cette méthode !

J'avais une autre question !
J'ai effectué mon free a la fin de ma fonction mere... Je me demandais si cela étais correct, dans le sens ou la taille de ma variable avait changée !!! Et en cherchant plus loin, est-il possible de ne pas faire le free, puisque la variable est déclarée dans la fonction, elle ser liberee à la sortie ???

Merci de ton aide crocodilex...

Le free est tout à fait correct du moment que que sztoto pointe sur un block alloué par malloc...

Thierry

[zooro]

Et en cherchant plus loin, est-il possible de ne pas faire le free, puisque la variable est déclarée dans la fonction, elle ser liberee à la sortie ???

Une règle : celui qui alloue la mémoire est chargé de la désallouer.
Ou plus simplement : un malloc, un free.

[xc78370]

Merci mujigka...

J'étais justement en train d'essayer de passer l'adresse du pointeur en parametre !!! Tu me fais avancer plus vite... Merci

Une règle : celui qui alloue la mémoire est chargé de la désallouée.
Ou plus simplement : un malloc, un free.

Oui mais dans mon cas, la taille d'alocation n'est connue que dans ma fonction fille et j'ai besoin de ma variable allouée dans la suite de ma fonction emer !!!


Merci à tous

[zooro]

Merci mujigka...

J'étais justement en train d'essayer de passer l'adresse du pointeur en parametre !!! Tu me fais avancer plus vite... Merci

Oui mais dans mon cas, la taille d'alocation n'est connue que dans ma fonction fille et j'ai besoin de ma variable allouée dans la suite de ma fonction emer !!!

Merci à tous

Le free n'a pas besoin que tu lui donnes la taille de la zone à libérer. Un pointeur avec la bonne adresse suffit.

Ce que je voulais dire, c'est que tu as appelé une fonction pour allouer de la mémoire, donc c'est à toi d'appeler une fonction (free en l'occurrence) pour la désallouer.

[Thierry Chappuis]

Merci mujigka...

J'étais justement en train d'essayer de passer l'adresse du pointeur en parametre !!! Tu me fais avancer plus vite... Merci


Oui mais dans mon cas, la taille d'alocation n'est connue que dans ma fonction fille et j'ai besoin de ma variable allouée dans la suite de ma fonction emer !!!


Merci à tous

Tu n'as qu'un prévoir un paramètre supplémentaire à ta fonction pour transmettre la taille allouée à la fonction appelante. Et tu n'as pas besoin de connaître la taille du bloc alloué pour libérer la mémoire.

Thierry

[koala01]

Salut,

A vrai dire, le gros problème c'est que, si tu passe un parametre à une fonction, tu déclare explicitement une variable locale à cette fonction du type et de la valeur de l'argument passé...

Cela signifie que, si tu veux qu'elle modifie la valeur d'une variable normale, tu dois lui passer l'adresse de la variable (un pointeur sur la variable), et, si tu veux qu'une fonction modifie un pointeur, tu dois en fait lui passer... l'adresse du pointeur (c'est à dire un pointeur de pointeur)... ou alors décider de renvoyer l'élément désiré (et de le récupérer dans la fonction appelante par variable=fonction()

Voici donc, de manière générale, les deux possibilités pour modifier une valeur de variable:

Code :

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

1
2
3
4
5
 
void Modif( type* parg)
{
    /*ici, il faut travailler sur "ce qui se trouve à l'adresse pointée par parg */
}

appelée sous la forme de

Code :

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

1
2
type valeur;
Modif(&valeur);

ou

Code :

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

1
2
3
4
5
6
7
 
type Modif()
{
    type renvoi;
    /* on modifie renvoi et on le renvoi */
    return renvoi;
}

dont l'appel se fera sous la forme de

Code :

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

1
2
3
 
type variable;
variable=Modif();

Avec les pointeurs, c'est la meme idée, sauf que, dans le premier cas, on passera un... pointeur de pointeur comme argument

Code :

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

1
2
3
4
5
6
7
8
 
void ModifPointeur(type ** pparg)
{
   /*pour modifier la valeur dans la fonction appelante, on travaillera sur 
      "ce qui est pointé par pparg"... ex: */
    *pparg=malloc(sizeof(type));/*évidemment, cette commande ci n'est pas
                      des plus sécus ;) */
}

appelée sous la forme de

Code :

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

1
2
3
 
type *ptr;
ModifPointeur(&ptr);

mais on peut aussi utiliser une fonction qui renvoie le pointeur...

Code :

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

1
2
3
4
5
6
7
8
 
/*nombre correspond ici au nombre d'éléments que l'on souhaite */
type* AllouePointeur(int nombre) 
{
    Type *ptr;
    ptr=malloc(nombre*sizeof(ptr));
    return ptr;
}

et qui sera appelée de manière conventionnelle:

Code :

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

1
2
3
4
5
6
7
8
9
10
11
 
type *ptrvar;
ptrvar=AllouePointeur(15);
if(ptrvar!=NULL)
{
    /*c'est ok */
}
else
{
    /* c'est pas ok */
}

L'utilisation des pointeurs sur quelque chose comme argument présente l'avantage de permettre la modification de valeurs tout en renvoyant, par exemple, le résutat global (réussite/échec) de la fonction... ex:

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
 
/* Renvoie 1 en cas de réussite, 0 en cas d'échec */
int Modification(int* parg, type2** ptr2)
{
    /*va tenter de modifier la valeur qui sera fournie en tant que parg,
      et de réallouer le pointeur fourni en tant que ptr2 */
    *parg+=5;
    type2 *nouveau;
    nouveau=malloc((*parg)*sizeof(type2));
    if(nouveau==NULL)
    {
        /* il faut retirer les 5 qu'on a rajouté à parg pour revenir à l'état 
            initial */
        *parg-=5;
        return 0;
    }
   /*libération de ce qui est pointé par ptr2 */
    if(*ptr2!=NULL)
        free(*ptr2);
    *ptr2=nouveau;
    return 1;
}

et qui sera appelée sous la forme de

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
 
int variable=10;
type2 *ptrvar=NULL;
int resultat;
resultat=Modification(&variable, &ptrvar);
if(resultat==1)
{
    /* ici, variable vaut 15 et ptrvar dispose de suffisemment de mémoire pour
        contenir 15 éléments */
}
else
{
    /* rien n'a changé ici */
}