Discussion :

[salseropom]

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

Code :

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

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 :

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

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 :

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

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 :

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
 
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

[doderic]

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.

[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 :

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

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);
  }
}

Et ai-je le droit de faire ceci :

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

Il faudrait que tu fasses :

Code :

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

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

[diogene]

souviron34 :

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.

Envoyé par salseropom

Et ai-je le droit de faire ceci :

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

Code :

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

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

[souviron34]

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 :

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
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...

[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 :

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

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

[Emmanuel Delahaye]

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 :

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
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 :

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

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...

[gl]

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

-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.)