à propos du cast et du void *

Version imprimable

Bonjour, j'ai 2 structures S1 et S2. J'ai 3 fonctions :

Code:

1
2
3
4
 
int mafct(void * p, int flag);
int fonction0(S1 * p);
int fonction1(S2 * p);

Est-ce que je peux faire ceci :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
 
int mafct(void * p, int flag)
{
  if(flag == 0)
  {
    return fonction0(p);
  }
  else
  {
    return fonction1(p);
  }
}

ou bien dois-je obligatoirement caster mon pointeur :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
 
int mafct(void * p, int flag)
{
  if(flag == 0)
  {
    S1 * pS1 = (S1 *) p;
    return fonction0(pS1);
  }
  else
  {
    S2 * pS2 = (S2 *) p;
    return fonction1(pS2);
  }
}

Et ai-je le droit de faire ceci :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
 
int mafct(void * p, int flag)
{
  void * ptr = NULL;
 
  if(flag == 0)
  {
    ptr = (S1 *) p;
    return fonction0(ptr);
  }
  else
  {
    ptr = (S2 *) p;
    return fonction1(ptr);
  }
}

Pour ma part, je fais la 1e méthode (sans le cast). Ces méthodes peuvent-elles engendrer des problèmes, comportements indéterminés etc ?

Merci d'avance

23/03/2009, 17h10
doderic

Citation:

Envoyé par salseropom

Pour ma part, je fais la 1e méthode (sans le cast). Ces méthodes peuvent-elles engendrer des problèmes, comportements indéterminés etc ?

Merci d'avance

Slat! non je ne pense pas que ça puisse engendrer des problèmes. c'est pas obligatoire, donc sois tranquille.
23/03/2009, 18h09
souviron34
Si, cela engendrera des problèmes....

Il suffit de compiler avec le flag -Wstrict_prototypes et tu te feras jeter...

En effet, tes fonctions ont une déclaration avec un S1* ou un S2*. Si le compilateur vérifie, il verra que l'appel ne correspond pas (void * n'est pas S1* ou S2 *).

Une solution simple dans ton cas est :
Code:

1 2 3 4 5 6 7 8 9 10 11 int mafct(void * p, int flag) { if(flag == 0) { return fonction0((S1 *)p); } else { return fonction1((S2 *)p); } }
Citation:

Envoyé par salseropom

Et ai-je le droit de faire ceci :

Non.. Un pointeur void * ne peut pas prendre un type...

Il faudrait que tu fasses :
Code:

1 2 S1 *ptr1 = (S1 *)p; S2 *ptr2 = (S2 *)p;
23/03/2009, 19h41
diogene
souviron34 :

Citation:

En effet, tes fonctions ont une déclaration avec un S1* ou un S2*. Si le compilateur vérifie, il verra que l'appel ne correspond pas (void * n'est pas S1* ou S2 *).

Non, le transtypage entre un pointeur et void * est implicite et réciproquement.

Citation:

Envoyé par salseropom

Citation:

Et ai-je le droit de faire ceci :

Non.. Un pointeur void * ne peut pas prendre un type...
Code:

1 2 3 4 5 6 int mafct(void * p, int flag) { void * ptr = NULL; ... ptr = (S1 *) p; ...
ptr = (S1 *) p est légal quoique le transtypage soit totalement inutile. ptr est et reste un void* (aucune variable en C ne peut changer de type) et ceci revient à faire ptr = p;
La troisième éventualité envisagée par salseropom est simplement équivalente à la première

Citation:

Envoyé par diogene

souviron34 :
Non, le transtypage entre un pointeur et void * est implicite et réciproquement.

teste en compilant avec -Wstrict_prototypes le code suivant, tel qu'indiqué dans le premier post du PO :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 int fonction0(S1 * p) { printf ( "S1\n"); return 0 ; } int fonction1(S2 * p); { printf ( "S2\n"); return 0 ; } int mafct(void * p, int flag) { if(flag == 0) { return fonction0(p); } else { return fonction1(p); } }
un compilateur bien réglé te jetteras...

24/03/2009, 07h30
salseropom
Merci de vos réponses (je ne me doutais pas que j'allais lever un débat...)

Je vais donc revenir à ma 1e solution (que j'avais effacée...)
Code:

1 2 3 S1 *ptr1 = (S1 *)p; S2 *ptr2 = (S2 *)p;

Citation:

Envoyé par souviron34

teste en compilant avec -Wstrict_prototypes le code suivant, tel qu'indiqué dans le premier post du PO :
<...>
un compilateur bien réglé te jetteras...

Pour d'autres raisons...

ceci fonctionne :

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
42
43
44
45
46
47
48
49
50
 
#include <stdio.h>
 
typedef struct
{
   int a;
}
S1;
 
typedef struct
{
   char *b;
}
S2;
 
int fonction0 (S1 * p)
{
   printf ("S1\n");
   return 0;
}
 
int fonction1 (S2 * p)
{
   printf ("S2\n");
   return 0;
}
 
int mafct (void *p, int flag)
{
   if (flag == 0)
   {
      return fonction0 (p);
   }
   else
   {
      return fonction1 (p);
   }
}
 
int main (void)
{
   S1 a1;
   S2 a2;
 
   mafct (&a1, 0);
   mafct (&a2, 0);
 
   return 0;
 
}

Code:

1
2
3
4
5
6
7
8
9
10
11
 
 
-------------- Build: Debug in hello ---------------
 
Compiling: main.c
Linking console executable: bin\Debug\hello.exe
C:\dev\hello\main.c:15: warning: unused parameter 'p'
C:\dev\hello\main.c:21: warning: unused parameter 'p'
Output size is 18.64 KB
Process terminated with status 0 (0 minutes, 0 seconds)
0 errors, 2 warnings

Il n'y a aucun cast à faire. Par contre, si on se trompe dans la valeur du flag, c'est le drame...

24/03/2009, 09h14
Emmanuel Delahaye
Citation:
Envoyé par salseropom

Merci de vos réponses (je ne me doutais pas que j'allais lever un débat...)

Je vais donc revenir à ma 1e solution (que j'avais effacée...)

Code:

1 2 3 S1 *ptr1 = (S1 *)p; S2 *ptr2 = (S2 *)p;
cast inutile.
24/03/2009, 11h48
doderic

Sincèrement le cast est inutile. si c'était en C++, là tu serais obligé de le faire (ou encore dans le cas que précise souviron) sinon ce n'est vraiment pas la peine de caster.
24/03/2009, 20h32
gl

Citation:

Envoyé par souviron34

Il suffit de compiler avec le flag -Wstrict_prototypes et tu te feras jeter...

En effet, tes fonctions ont une déclaration avec un S1* ou un S2*. Si le compilateur vérifie, il verra que l'appel ne correspond pas (void * n'est pas S1* ou S2 *).

Le rôle de Wstrict-prototypes n'est pas celui-ci

Citation:

-Wstrict-prototypes (C and Objective-C only)
Warn if a function is declared or defned without specifying the argument types.
(An old-style function defnition is permitted without a warning if preceded by
a declaration which specifes the argument types.)