Discussion :

[MegaNono]

si je fais un malloc ds une fonction, et que je "return" le pointeur :

Code :

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

1
2
3
4
5
6
7
8
9
 
char * mafonction(){
         char * ptr;
 
         ptr = malloc ( x * sizeof(char));   // x car peu importe le nb
 
         (...)
          return ptr;
}

ensuite un appel

Code :

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

1
2
3
4
 
char * ptr2;
 
ptr2 = mafonction();

En terme de mémoire, le pointeur ptr est detruit ?
Ds ce cas j'ai juste a faire free(ptr2) pour tout libérer ?

[Emmanuel Delahaye]

si je fais un malloc ds une fonction, et que je "return" le pointeur :

Ce que tu retournes est une valeur. Ici, cette valeur est une adresse. C'est l'adresse du bloc alloué.

Code :

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

1
2
3
4
5
6
7
8
9
 
char * mafonction(){
         char * ptr;
 
         ptr = malloc ( x * sizeof(char));   // x car peu importe le nb
 
         (...)
          return ptr;
}

ensuite un appel

Code :

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

1
2
3
4
 
char * ptr2;
 
ptr2 = mafonction();

En terme de mémoire, le pointeur ptr est detruit ?

Oui, comme toute variable automatique...

Ds ce cas j'ai juste a faire free(ptr2) pour tout libérer ?

Oui.

[MegaNono]

merci

[fearyourself]

Penses au résolu qui se trouve dans le menu "Outils de la discussion" en haut à droite...

Jc

[Pragmateek]

Je croyais qu'il était impossible de construire des tableaux dans des fonctions et les récupérer de quelque manière que ce soit.

Donc ceci est seulement vrai pour les tableaux statiques?
Et donc on peut allouer un tableau dans une fonction et le récupérer et manipuler sans problème en dehors de la fonction?

[Emmanuel Delahaye]

Je croyais qu'il était impossible de construire des tableaux dans des fonctions et les récupérer de quelque manière que ce soit.

Donc ceci est seulement vrai pour les tableaux statiques?
Et donc on peut allouer un tableau dans une fonction et le récupérer et manipuler sans problème en dehors de la fonction?

Le principe général c'est que l'adresse retournée doit être valide. Point. Tu appliques ensuite ce principe au cas par cas.

D'autre part, on ne sait pas passer/retourner de tableau, mais seulement l'adresse du premier élément de celui-ci (ou l'adresse du tableau, mais c'est plus rare et pas très pratique...)

[Pragmateek]

Code :

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

1
2
3
4
5
6
7
8
9
int* f(){
         int t1[]={1,2,3};
         return t1;
         }
 
...
 
int *t2=f();
printf("%d",t2[2]);

fonctionne en effet alors que j'ai "toujours" vu: t2 sera invalide.

Est-ce risqué de faire cela par rapport à:

Code :

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

1
2
3
4
5
6
void f(int *t){
         t[0]=1;
         t[1]=2;
         t[2]=3;
         return;
         }

?

[crocodilex]

Code :

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

1
2
3
4
5
6
7
8
9
int* f(){
         int t1[]={1,2,3};
         return t1;
         }
 
...
 
int *t2=f();
printf("%d",t2[2]);

fonctionne en effet alors que j'ai "toujours" vu: t2 sera invalide.
[/code] ?

Cela fonctionne parceque tu explotes t2 aussitot après le retour de ta fonction. La pile n'est pas altérée.

Mais si tu fais :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
int* f(){
          int t1[]={1,2,3};
          return t1;
}
 
 ...
 
int *t2=f();
autreFonction();
printf("%d",t2[2]);

Il y a de forte chance que ton pointeur t2 ne soit plus valide.

[diogene]

Code :

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

1
2
3
4
5
6
7
8
 
int* f(){
         int t1[]={1,2,3};
         return t1;
         }
...
int *t2=f();
printf("%d",t2[2]);

fonctionne en effet alors que j'ai "toujours" vu: t2 sera invalide.

Non, le code est erroné pour les raisons exposées par Emmanuel : L'adresse retournée cesse d'être valide puisque t1 est détruit en sortie de fonction. Si ca semble marcher, c'est pur hasard et mauvaise chance.
Si on veut créer le tableau dans la fonction et qu'il survive à la sortie, il faut le faire par allocation dynamique

Est-ce risqué de faire cela par rapport à:
Code :

Code :

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

1
2
3
4
void f(int *t){ t[0]=1;
 t[1]=2;
 t[2]=3;
 return; }

Ceci est peut être juste : il faut que l'argument t corresponde à un tableau de 3 éléments au moins.

[Emmanuel Delahaye]

fonctionne en effet alors que j'ai "toujours" vu: t2 sera invalide.

T'as rien compris à ce que j'ai dit. L'adresse retournée doit être valide.

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
 
#include <stdio.h>
static int* f(void)
{
   int t1[] =
      {
         1, 2, 3
      };
   return t1;
}
 
int main (void)
{
   int *t2 = f();
   printf("%d", t2[2]);
   return 0;
}

Or, à l'évidence, elle ne l'est pas. Un compilateur bien reglé s'en rend compte :

Code :

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

1
2
3
4
5
6
7
 
Compiling: main.c
main.c: In function `f':
main.c:8: warning: function returns address of local variable
Linking console executable: C:\dev\forums\OP\01.exe
Process terminated with status 0 (0 minutes, 0 seconds)
0 errors, 1 warnings

[Emmanuel Delahaye]

Cela fonctionne parceque

Non. Ca ne fonctionne pas du tout. Le comportement est indéfini. Point.

[Pragmateek]

T'as rien compris à ce que j'ai dit.

En effet.

1)Alors à quoi peut servir de renvoyer l'adresse du premier élément si ce n'est pas valide?
2)Par contre est-ce que ç'est valide si t est alloué dynamiquement?

[crocodilex]

Non. Ca ne fonctionne pas du tout. Le comportement est indéfini. Point.

Nous savons tous que le comportement est indéfini. J'essayais juste de lui donner une explication (ce n'est peut etre pas la meilleure), à savoir pourquoi dans son exemple, cela pouvait marcher. C'est tout.

[Emmanuel Delahaye]

1)Alors à quoi peut servir de renvoyer l'adresse du premier élément si ce n'est pas valide?

Ce n'est pas parce que c'est techniquement possible que c'est valide. Le C est plein d'exemples comme ça.

• lire une variable non initialisée
• déréférencer un pointeur non initialisé
• ecrire au-dela des limites d'un tableau
• etc.

2)Par contre est-ce que ç'est valide si t est alloué dynamiquement?

Déjà répondu.

[Emmanuel Delahaye]

Nous savons tous que le comportement est indéfini. J'essayais juste de lui donner une explication (ce n'est peut etre pas la meilleure), à savoir pourquoi dans son exemple, cela pouvait marcher. C'est tout.

Perte de temps. On ne peut pas définir ce qui est indéfini. Ca parait logique, non ?

[Pragmateek]

Déjà répondu.

Donc oui, c'est valable.