Retourner 2 pointeurs

Version imprimable

23/05/2006, 14h16
nunurs83

Retourner 2 pointeurs

Voila j'aurai besoin d'une fonction qui prend 2 pointeurs en paramètre,
qui en retourne un grâce au return mais je souhaiterai aussi récupérer le deuxième pointeur sur lequel j'ai fait des traitements et je ne sais pas comment faire :(
merci pour votre aide
23/05/2006, 14h19
Eusebius

Est-ce que tu as modifié les pointeurs eux-mêmes, ou la valeur pointée ?
23/05/2006, 14h23
salseropom
salut, tu devrais faire qqch du genre (si ne ne me trompe pas) :
Code:

1 2 3 4 5 6 7 8 9 10 T * p=f(T1 * p1,T2 * p2,T3 * p3) { T * p=malloc(sizeof(*T)); assert(p!=NULL); blabla return p; }
où T, T1, T2 et T3 sont 4 types (int, double etc....) et où tu ne modifies que les objets pointés par p3.

je ne modifie que la valeur pointée.
Code:

1 2 3 4 5 6 7 8 9 10 Maillon * GestionFic(Maillon *MaChaine, Maillon *MaChaineInverse) { FILE *pf = ouvrir_fichier(); MaChaine = Lecture_Fic(pf, MaChaine); fermer_fichier(pf); return MaChaine; }
en gros j'ai ça, mais je veux aussi récupérer MaChaineInverse, bon là j'ai pas mis le traitement associé.

Citation:

Envoyé par nunurs83

je ne modifie que la valeur pointée.

Alors tu n'as pas besoin de faire un return :
Code:

1 2 3 4 5 6 7 8 9 10 void f(T * p1, T * p2) {...} int main(void) { T *p1 = machin; T *p2 = truc; f(p1, p2); // Et tu continues avec *p1 et *p2 éventuellement modifiés. }

23/05/2006, 14h30
nunurs83

et si je modifie les pointeurs eux-mêmes ? :mrgreen:
23/05/2006, 14h32
Eusebius

Citation:

Envoyé par nunurs83

et si je modifie les pointeurs eux-mêmes ? :mrgreen:

Ben tu les passes par adresse.
23/05/2006, 14h32
Gruik

Si tu modifies les pointeurs eux meme c'est que ce sont des parametres en mise à jour et il n'y a pas à les retourner
Pour creer un parametre en mise à jour, il suffit de passer un pointeur sur celui-ci
Ce qui revient à passer un T ** à ta fonction

Code:

1
2
3
4
5
6
7
8
9
10
11
 
T **p1;
T **p2;
 
void f(p1, p2);
 
void f(T **p1, T **p2)
{
   p1 = huhu(); /* ou *p1 = huhu(); ?? */
   p2 = huhu2();
}

ce qui doit donner ça en gros ?

Avec les pointeurs passés par adresse :

Code:

1
2
3
4
5
6
7
8
9
10
void f(T ** p1, T ** p2) {...}
 
int main(void) {
 
  T *p1 = machin;
  T *p2 = truc;
  f(&p1, &p2);
  // Et tu continues avec p1 et p2 éventuellement modifiés.
 
}

23/05/2006, 14h48
nunurs83

Merci je vais tester tout ça :)
23/05/2006, 15h27
gege2061
Citation:
Envoyé par salseropom

Code:

1 2 T * p=malloc(sizeof(*T)); assert(p!=NULL);
assert n'est pas une bonne méthode pour tester l'échec de malloc. Cette macro ne génére aucun code si la macro NDEBUG est définie (mode release) donc généralement chez le client, où la loi de Murphy est reine ;)
23/05/2006, 15h33
salseropom
Salut gege2061,
vaut-il alors mieux que je fasse
Code:

1 2 3 T * p=malloc(sizeof(*p)); if(p==NULL) exit(EXIT_FAILURE);
23/05/2006, 15h36
gege2061
Citation:
Envoyé par salseropom

vaut-il alors mieux que je fasse

Code:

1 2 3 T * p=malloc(sizeof(*p)); if(p==NULL) exit(EXIT_FAILURE);
Oui, c'est mieux :ccool:

Citation:
Envoyé par Eusebius
Avec les pointeurs passés par adresse :
Code:

1 2 3 4 5 6 7 8 9 10 11 void f(T ** p1, T ** p2) {...} int main(void) { T *p1 = machin; T *p2 = truc; f(&p1, &p2); // Et tu continues avec p1 et p2 éventuellement modifiés. }
Techniquement, oui. Mais dans la pratique, c'est atroce et ça génrère du code grand guignolesque. Dans la pratique réelle, on utilise plutôt une structure :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 struct data { T *p1; T *p2; }; void f (struct data mydata* p_data) {...} { struct data mydata; mydata.p1 = machin; mydata.p2 = truc; f (&mydata); }
Tout l'art du concepteur est de regrouper en structure les données ayant un intérêt commun.

Par exemple :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 struct node { /* link */ struct node *p_next; /* data */ void *p_data; }; struct list { struct node *p_head; struct node *p_tail; };
etc.

Citation:

Envoyé par salseropom

Salut gege2061,
vaut-il alors mieux que je fasse

Code:

1
2
3
 
T * p=malloc(sizeof(*p));
if(p==NULL) exit(EXIT_FAILURE);

C'est possible, mais c'est brutal, surtout sans explication...

Code:

1
2
3
4
5
6
7
 
   T * p = malloc (sizeof *p);
   if (p == NULL) 
   {
      fprintf (stderr, "memory error at %s:%d\n", __FILE__, __LINE__);
      exit (EXIT_FAILURE);
   }

Ce qui se termine généralement en

Code:

1
2
3
4
5
6
7
8
9
10
11
 
#define PERR(msg)\
      fprintf (stderr, #msg " at %s:%d\n", __FILE__, __LINE__)
...
 
   T * p = malloc (sizeof *p);
   if (p == NULL) 
   {
      PERR ("memory error");
      exit (EXIT_FAILURE);
   }

puis en

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
 
#define PERR(msg)\
      fprintf (stderr, #msg " at %s:%d\n", __FILE__, __LINE__)
 
#define MYASSERT(exp)\
do\
{\
   if (!(exp)) \
   {\
      PERR (#exp " not asserted");\
      exit (EXIT_FAILURE);\
   }\
}\
while (0)
 
   T * p = malloc (sizeof *p);
   MYASSERT (p != NULL);

(NON TESTE)

24/05/2006, 10h33
salseropom

merci pour tes macros Emmanuel. Elles vont bien me simplifier la vie.