comment utiliser free

Bonjour,

j'ai un petit doute sur l'utilisation de free(x), lorsque je veux que ma fonction retourne x. Doit-on faire free(x) puis return(x) (à mon avis ce return ne marche pas), ou return(x) puis free(x) (x est-il vraiment libéré?) ou faut-il créer une variable locale y=x, ou existe-t-il un moyen plus élégant?
Voici ce que je souhaite faire (tout en libérant res au bon moment) :

Code:

---

1 2 3 4 5 6 7

char *time_t_to_string (time_t t) { time_t *pt = &t; char *res = (char*) calloc (16, sizeof(char)); res[16] = '\0'; strncpy (res, ctime (pt) + 4, 15); }

---

Merci pour votre aide.

:salut:

Regarde dans la :faq: <== Click on me !

Je connaissais l'idée de passer un pointeur à la fonction, mais j'aurais voulu l'éviter.
J'avais commencé par une chaîne statique, mais ça ne marche pas :

Code:

---

1 2 3 4 5 6 7

const char *time_t_to_string (time_t t) { time_t *pt = &t; char res[16]; res[16] = '\0'; strncpy (res, ctime (pt) + 4, 15); }

---

Avec une chaîne déclarée en 'static' ça fonctionne :

Code:

---

1 2 3 4 5 6 7 8

const char *time_t_to_string (time_t t) { time_t *pt = &t; static char res[16]; res[16] = '\0'; strncpy (res, ctime (pt) + 4, 15); return res; }

---

Citation:

---

j'ai un petit doute sur l'utilisation de free(x), lorsque je veux que ma fonction retourne x. Doit-on faire free(x) puis return(x) (à mon avis ce return ne marche pas)

---

Il ne marche pas : tu retournerais l'adresse d'une variable détruite (même problème avec char res[16]).

Citation:

---

ou return(x) puis free(x) (x est-il vraiment libéré?)

---

Non, il ne sera pas libéré parce que tu quitteras la fonction avant l'exécution du free().

-Tu ne peux donc faire le free() qu'après avoir retourné le x, donc hors de la fonction.

-Il est aussi possible de laisser la question de création/destruction du tableau au code appelant la fonction :

Code:

---

1 2 3 4 5

void time_t_to_string (time_t t, char* res) { strncpy (res, ctime (&t) + 4, 15); res[16] = '\0'; }

---

Bonjour,
merci à vous deux pour ces réponses.
Diogène, pouvez-vous expliquer plus en détail pourquoi c'est le "même problème avec char res[16]' ?

Ce que Diogene veut dire c'est que tu ne peut (en C) retourner l'adresse d'un ELEMENT LOCAL à une fonction.

En effet lorsque tu appel ta fonction tu va réserver une zone mémoire pour celle-ci. Cette zone est libérée a la fin de l'execution de la fonction.

Donc, à moins que tu n'ai déclaré ton élément en "static", tu ne peut retourner l'adresse.

Cette regle ne s'applique pas aux éléments STATIC ni aux éléments que tu alloue dans la fonction.

J'ai tout a fait le droit de faire :

Code:

---

1 2 3 4 5 6

char * ma_fonc(void) { char *pt; pt=malloc(50); return pt; }

---

Si bien sur on met de côté les erreurs de compilations et autre du au malloc etc etc...

Je peut aussi faire :

Code:

---

1 2 3 4 5

char * ma_fonc(void) { static char pt[50]; return pt; }

---

Mais dans ce cas, a chaque appel de ma_fonc je viendrai ecraser le resultat précédant... donc attention...

La portée d'une variable est interne au bloc dans lequel elle est déclarée excepté les static et les alloués.

attention à quoi? (Y a-t-il un problème spécifique à utiliser cette solution par rapport aux autres ?)

Bah en fait quand tu déclares en static tu retournes un pointeur sur ce tableau. Mais si tu tentes de modifier le tableau dans la fonction appelante tu modifieras aussi le tableau de la fonction ma_fonc. Du coup si tu veux sauvegarder le pointeur tu ne peux pas, tu es obligé de passer par un strcpy.

ok, merci à tous pour vos réponses.

Citation:

---

Je peut aussi faire :

Code:

---

1 2 3 4 5

char * ma_fonc(void) { static char pt[50]; return pt; }

---

Mais dans ce cas, a chaque appel de ma_fonc je viendrai ecraser le resultat précédant... donc attention...

---

Oui, attention !
Pas tellement parce que le tableau peut être modifié à chaque appel de la fonction car après tout, on peut s'y attendre.
Mais surtout, il peut être modifié à l'extérieur de la fonction puisqu'on a communiqué son adresse ce qui lui donne implicitement tous les défauts liés aux variables globales (avec l'aggravation que les interventions sur cette variable ne sont plus directes mais "masquées" par l'utilisation de l'adresse )