Global, static ou autre ?

Voici une petite question que je me posait.

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

Code:

---

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:

---

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:

---

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

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:

---

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.

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:

---

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:

---

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

Citation:

---

Envoyé par rilou

Code:

---

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:

---

1 2	long effacerDeLaListe(struct listr *);

---

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

Quand tu fais :

Code:

---

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:

---

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:

---

1 2 3 4

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

---

Hadrien

Citation:

---

Envoyé par rilou

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:

---

1 2 3 4 5 6 7 8 9

... { T *p = fonction_retournant_adresse(); if (p != NULL) { /* usage */ free (p), p = NULL; }

---

hallelouya :p enfin une réponse xD

Merci Emmanuel.

Citation:

---

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

Citation:

---

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