Discussion :

[rilou]

Voici une petite question que je me posait.

Disons que j'ai une fonction devant retourner une adresse comme ceci :

Code :

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

1
2
3
4
5
6
 
void* fonction_retournant_adresse()
{
     ...
     return ... ;
}

La meilleur façon de retourner cette adresse serait de quel façon
(SUPPOSANT BIENSUR que dans aucun cas je n'ai le droit de modifier la liste des paramètres).

1) Une variable 'static' qui aurait une adresse fixe ?

Code :

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

1
2
3
4
 
static int maVariableStatic;
...
return &maVariableStatic;

2) Une variable globale ? et dans ce cas on "vire" le void* de retour ? (bouh c'est mal le global, mais pourquoi pas ?!)

3) Allouer une variable et retourner son adresse ? (ce qui poserait des zone mémoire inutilisable par la suite)

Code :

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

1
2
3
4
5
6
 
int *maVar;
maVar=calloc(50, sizeof *maVar );
...
...
return maVar;

Ou bien une autre méthode ?
C'est juste pour information personnelle.

Dites moi tout :p

Merci

[jeroman]

Chaque fonction a une utilité qui lui est propre. Si une fonction en appelle une autre, il faut en principe lui fournir de quoi lui permettre de travailler, c'est-à-dire en lui envoyant les arguments dont elle a besoin. Ca permet une certaine cohérence dans le programme et de le structurer correctement.
Le problème des globales, c'est que ça dénature quelque peu la structure du programme et cela peut provoquer des conséquences inattendues du fait que n'importe quelle fonction peut modifier sa valeur.
Les variables locales statiques ont un peu le même soucis, car n'importe quelle fonction qui appelle cette fonction (dans laquelle il y a la variable statique) peut la rendre susceptible de modifier sa valeur, sans passer aucun argument. Ca destructure le programme et peut être générateur de bugs si on n'est pas vigilant.

Après, ta question est trop générale. Il faudrait un exemple concret. Mais en fonction de tel ou tel besoin, il y a toujours une solution adaptée.

Par exemple, rien ne t'interdit de passer un argument (pointeur) à une fonction afin qu'elle modifie la valeur de l'objet passé par adresse en argument... voire même la valeur du pointeur passé en argument (pointeur sur pointeur) via l'adresse du pointeur (pour allouer de la mémoire via une fonction perso par exemple et modifier la valeur du pointeur d'origine).

Exemples parmi d'autres :

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
void fonction1(int *valeur)
{
  *valeur=10;
}
void alloc_memoire(int **pointeur)
{
  *pointeur=malloc(10*sizeof(int));
}
int main(void)
{
  int a;
  int* p_b=NULL;
  fonction1(&a); /* "a" vaut 10 */
  alloc_memoire(&p_b); /* "p_b" est modifié et pointe désormais sur la mémoire allouée */
  free(p_b);
  return 0;
}

Tu peux aussi passer en argument une structure ou un pointeur de structure selon tes besoins, etc.

[rilou]

ha oui bien sur, tout à fait d'accord mais en fait j'ai rencontré ce problème récemment et j'ai du y faire face a grand coup de STATIC :p

En fait j'avait la fonction suivante :

Code :

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

1
2
 
void * effacerDeLaListe(struct listr *);

Et cette fonction avait pour but de supprimer le premier élément de ma liste et de renvoyer la valeur qu'elle contenait.

Supposons l'exemple suivant :

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
 
struct Liste
{
     struct Liste * suivante;
     long objet;
}
 
int main (void)
{
   struct Liste * neuve;
   long *pElem;
 
   neuve=malloc(sizeof *neuve);
   if(!neuve) return EXIT_FAILURE;
 
   neuve->suivante=malloc(sizeof *neuve);
   if(!neuve->suivante) return EXIT_FAILURE;
 
   neuve->objet=100;
   neuve->suivante->objet=50;
 
   pElem=effacerDeLaListe(neuve); //manque peut-être un cast ?! O.o
 
   printf("%u",*pElem);
 
   return EXIT_SUCCESS; // merci gl :p
}
 
//voila a quoi ressemblait ma fonction
void* effacerDeLaListe(struct Liste* list)
{
   static long pEL;
   struct List* aDelete;
 
   aDelete=list;
   pEL=list->objet;
   list=list->suivante;
   free(aDelete);
 
   return &pEL;
}

Passons outre les (probable qui a dit ca ?) erreur de compilation ainsi que les autre probables erreurs (j'ai fait ça sur le tas...) voici grosso modo a quoi ça ressemblait.
IMPOSSIBILITEE de modifier la definition de la fonction effacerDeLaListe.

Donc je me suit dit : Vu qu'il faille liberer l'espace mémoire le mieux a faire serait de retourner un pointeur sur un variable don l'adresse n'est pas modifier et le contenu que par cette fonction.


Tout de même plus lisible qu'une globale O.o

[orfix]

Code :

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

void * effacerDeLaListe(struct listr *);

Et cette fonction avait pour but de supprimer le premier élément de ma liste et de renvoyer la valeur qu'elle contenait.

Dans ce cas le prototype de ta fonction serait :

Code :

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

1
2
 
long effacerDeLaListe(struct listr *);

[sopsag]

En fait, ta fonction ne fait pas ce que tu veux :

Quand tu fais :

Code :

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

1
2
3
4
long effacerDeLaListe(struct Liste * list)
{
    /*...*/
    list=list->suivante;

tu modifies la valeur qui est sur la pile, et cette modification sera pardue au retour de la fonction.

Il faut faire ça :

Code :

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

1
2
3
4
5
6
7
8
long effacerDeLaListe(struct Liste ** list)
{
   long pEL=(*list)->objet;
   struct List* aDelete = *list ;
   *list=(*list)->suivante;
   free(aDelete);
   return pEL;
}

et du coup, dans le main tu retrouves ça :

Code :

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

1
2
3
4
   long Elem;
   /*...*/ 
   Elem=effacerDeLaListe(&neuve); 
   printf("%u",Elem);

Hadrien

[Emmanuel Delahaye]

La meilleur façon de retourner cette adresse serait de quel façon

1) 2) : NON.

3) Allouer une variable et retourner son adresse ? (ce qui poserait des zone mémoire inutilisable par la suite)

La dernière. Il faut penser à mémoriser l'adresse retournée pour pourvoir la tester avant usage et libérer le bloc.

Usage :

Code :

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

1
2
3
4
5
6
7
8
9
 
...
{
   T *p = fonction_retournant_adresse();
   if (p != NULL)
   {
      /* usage */
      free (p), p = NULL;
   }

[rilou]

hallelouya :p enfin une réponse xD

Merci Emmanuel.

Dans ce cas le prototype de ta fonction serait :

Mais non pas du tout ... puisque dans mon cas présent (comme dit 2 fois de suite) :

IMPOSSIBILITEE de modifier la definition de la fonction effacerDeLaListe.

A croire qu'on lit à moitier :p


Bref donc on retourne l'adresse et on s'occupe de liberer la mémoire dans le main. Merci