retourner plusieurs variable par une fonction Résolu/Fermé

Question

slt tt le monde jai un probleme c'set que je veux retourner plusieurs valeurs par une fonction et j'arrive pos a reussir,je sais ke peut etre je dois utiliser un tableau(plutoto pointeur)mais quand jexecute le programme il me retourne juste la premier valeur du tableau voila un ptit exemple #include #include int test() { int *p; p=malloc(4*sizeof(int)); *(p+0)=1; *(p+1)=2; *(p+2)=3; *(p+3)=4; return *p; } main() { int *tab,i; tab=malloc(4*sizeof(int)); *tab=test(); for(i=0;i<4;i++) printf("%d ",*(tab+i)); } voila ce programme me donne juste la premier valeur du tableau(la valeur 1)et pour les autres valeurs il me donne des adraisses. svp jai besoin d'aide merci de maider

mamiemando · Accepted Answer

Ton programme corrigé : #include #include int *test(){ int *p; p = malloc(4*sizeof(int)); p[0] = 1; p[1] = 2; p[2] = 3; p[3] = 4; return p; } int main(){ int *tab; int i; tab = malloc(4*sizeof(int)); tab = test(); for(i=0;i<4;i++) printf("%d ",tab[i]); free(tab); return 0; } Bonne chance

abdess111 · Answer

merciiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiii merci bcp
mnt je peux continuer mon programme :-)

mamiemando · Answer

Héhé bon courage ;-)

Char Snipeur · Answer

Salut.
Sinon, pour retourner plusieurs variable, tu peux aussi utiliser une structure.
Tu peux aussi retrouner des types différents, comme par exemple :
void* fct()
    {
    void *p;
    p=malloc(sizeof(int)+sizeof(double));
    *(int*)p=3;
    *(double*)((int*)p+1)=3.002;
    return p;
    }
-> 3h, j'ai rien compris à ton problème.

Char Snipeur · Answer

Voici un autre exemple, avec une structure pour exemple :
void* fct()
    {
    void *p;
    p=malloc(sizeof(int)*2+sizeof(double));
    *(int*)p=3;
    *(int*)(long(p)+sizeof(int))=5;
    *(double*)(long(p)+2*sizeof(int))=3.002;
    return p;
    }
int main()
{
    void *a;//=malloc(sizeof(int)+sizeof(double));  
    struct lastruct {int a;int c;double b;} *ess;
    a=fct();
    printf("a1 %d a2 %f
",*(int*)a,*(double*)(long(a)+2*sizeof(int)));
    ess=(lastruct*)fct();
    printf("a1 %d a2 %e
",ess->a,ess->b);
    scanf("%d",a);
    return 0;
}
Mais il faut faire attention à ce type de manipulation, car ça dépend de l'implémentation du compilateur utiliser. En particulier, les structures sont régies par un alignement des données assez complexe. Par exemple, si j'enleve la variable c de lastruct, la structure aura toujours la même taille en mémoire, le compilateur (gcc) créeant un espace vide entre a et b.

mamiemando · Answer

Dans le genre gore c'est pas mal :) Pourquoi tu ne retournes pas simplement directement la structure (ce qui t'évitera en plus d'oublier de faire un free).

_mawashi · Answer

Salut à tous,

J'ai un doute tout d'un coup et j'aimerais être sûr de ce que je fais. Lorsqu'on déclare une variable dans un sous-programme, la mémoire qui lui est associée est libérée à la fin de l'exécution de ce sous-programme c'est bien ça ? Dans mon exemple, c'est un peu comme au dessus, je retourne un pointeur pour lequel j'ai fait un malloc.
Ma question est de savoir si le fait de finir l'exécution (de test() dans l'exemple ci'dessus) et donc de retourner le pointeur libèrera bien l'espace mémoire pris par le malloc sans avoir à faire de free ? D'après le bout de code de mamiemando ça a l'air d'être le cas mais j'aimerais en être sûr.

Merci d'avance ;)

loupius · Answer

Oui et non.
Oui à la première question: une variable déclarée dans un sous-programme est libérée à la fin de l'exécution du sous-programme.
Non à la seconde question: l'espace alloué par malloc n'est pas libéré.
Explication:
Le pointeur declaré dans le sous-programme est une variable locale (dont l'adresse est dans la 'pile' (stack)); la valeur de ce pointeur est modifiée par 'malloc'; la valeur de ce pointeur est désormais une adresse de zone mémoire (qui est dans le 'tas' (heap)).
Lors de la terminaison du sous-programme, la pile est remise dans l'état précédant l'appel à ce sous-programme; en conséquence le pointeur est perdu... mais la zone mémoire antérieurement désignée par le pointeur reste allouée, et comme on a perdu l'adresse de cette zone, on se trouve avec une fuite mémoire.
Donc il y a deux solutions pour traiter les allocations dans un sous-programme:
- libération de l'espace mémoire par la fonction 'free',
- retourner le pointeur à la fonction appelante qui aura la responsabilité de la libération.
Voilà, c'est tout simple quand on a compris le mécanisme.
Bonne continuation.

Char Snipeur · Answer

Salut.
La règle est simple : à chaque malloc() doit correspondre un free().
Les exceptions sont rares.

_mawashi · Answer

Merci à tous les deux pour vos réponses.
Je me doutais bien que c'était comme ça, au moins maintenant je suis sûr.
Par contre par rapport aux solutions proposées par loupius, je ne sais pas comment les appliquer dans mon (qui est quasi identique à celui de ce thread). 
Pour la première solution,dans notre cas, comment peut on libérer p tout en voulant le retourner ?
Après je sais pas si je vois pas non plus comment l'appelant peut le faire à moins de connaitre la variable, ce qui fait perdre tout l'intérêt à mon programme :(

mamiemando · Answer

Pour la première solution,dans notre cas, comment peut on libérer p tout en voulant le retourner ? 

Ca n'a pas de sens. Il faut faire le free après avoir fini d'utiliser le bloc mémoire à l'adresse p et ensuite faire un free(p).

Après je sais pas si je vois pas non plus comment l'appelant peut le faire à moins de connaitre la variable, ce qui fait perdre tout l'intérêt à mon programme :(

Je n'ai pas compris ce que tu cherchais à faire.

_mawashi · Answer

Désolé mais je n'avais pas bien compris ton exemple (Mamiemando). En fait, pour moi tu ne libérais pas p mais tu libères bien l'espace par le free(tab) si j'ai (finalement) bien compris (l'adresse du pointeur ayant été retournée).

mamiemando · Answer

Oui c'est ça. À la sortie de test la variable locale p est désallouée (mais ce n'est qu'une adresse, et ça ne désalloue pas l'espace mémoire qu'elle pointe). Comme je retourne l'adresse dans ma fonction, je récupère dans main cette adresse. Une fois que je n'ai plus besoin de ce bloc mémoire je peux le désallouer avec un free.

Qui dit malloc dit free...

Retourner plusieurs variable par une fonction

13 réponses

Discussions similaires