Discussion :

[baert]

Bonjour,

J'ai des structure, (definie avec typedef struct{} ),

J'ai une fonction qui doit me servir a faire passer ces structures, avec en parametre:
un int, puis les donnees (contenant la structure)

Message(int nType, struct myStruct);

est il possible d'avoir une fonction sans preciser le type de la structure, mais en le castant apres (grace au type) ?

[Médinoc]

Non, tu ne peux pas caster de structure en structure.
Par contre, on peut caster des pointeurs vers structure, mais là, tu n'as pas vraiment l'air de savoir ce que tu fais, alors n'y pense même pas: Réfléchis en profondeur avant...

[keil]

meme si tu pense que c'est pas une solution pour lui, d'autres pourraient etre intéressé, donc tu pourrais quand meme donner la solution.

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
 
void blabla()
{
    struct maStructure b;
    b.x = 2;
    b.y = 3;
    int j = ouai( 1, &b);
}
 
int ouai(int h, void *ptr)
{
    struct maStructure *s = NULL;
 
    if(h==1)
       s = (struct maStructure*)ptr;
 
    if(s != NULL)
       printf("%d, %d\n", s->x, s->y);
    else
        return 0;
    return 1;
}

si tu ne comprends pas cet exemple, en effet, tu devrais passer par une autre methode.

[Médinoc]

là par contre, je remplacerais le cast de type C par un static_cast (sur un void*, un static_cast suffit).

Cela évitera des erreurs si un jour le pointeur est passé en const...

[keil]

"static_cast", je ne connaissait pas, j'en apprend tous les jours! je vais me renseigner dessus. merci pour cette info

[Médinoc]

ce sont les opérateurs de cast du C++ : Ils sont plus restrictifs, donc permettent moins d'erreurs.

Par exemple, static_cast et reinterpret_cast ne permettent en aucun cas de caster un pointeur const en pointeur non-const.
Si on se retrouve acculé à le faire, il faut employer explicitement l'opérateur const_cast pour cela (ou un cast de type C).

Je me demande s'il existe un paramètre de GCC pour interdire les casts de type C, mais malheureusement certains headers de la STL en contiennent...

[Kaktus]

est il possible d'avoir une fonction sans preciser le type de la structure, mais en le castant apres (grace au type) ?

Oui mais pour cela, il faut organiser tes structures en héritage. Comme ça, pas besoin de déterminer le type.
Si tous les types sont connus à la compilation, tu peux même opter pour des templates.


Pouurais-tu nous donner un exemple en code de ce que tu veux faire?

[Laurent Gomila]

L'équivalent plus typesafe et maintenable à ça :

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
void Fonction(int Type, void* Data)
{
    switch (Type)
    {
        case 1 :
        {
            Struct1* s = reinterpret_cast<Struct1*>(Data);
            F1(s);
            break;
        }
        case 2 :
        {
            Struct2* s = reinterpret_cast<Struct2*>(Data);
            F2(s);
            break;
        }
        case 3 :
        {
            Struct3* s = reinterpret_cast<Struct3*>(Data);
            F3(s);
            break;
        }
 
        ...
    }
}

C'est ça :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
void Fonction(Struct1 s)
{
    F1(s);
}
 
void Fonction(Struct2 s)
{
    F2(s);
}
 
void Fonction(Struct3 s)
{
    F3(s);
}

En règle générale.

[keil]

la je comprend rien,
F1, F2, F3, c'est des fonctions qui contiennent quoi?

[Laurent Gomila]

la je comprend rien,
F1, F2, F3, c'est des fonctions qui contiennent quoi?

Rien de spécial, c'est juste une manière de dire qu'après tu fais ce que tu veux de ton instance s, et pas forcément la même chose pour chaque type.

[keil]

ok, j'ai capté!
tu surcharge la fonction Fonction.
mais bon, baert ne nous a pas dit si son paramètre 'type' etait destiné a faire des tests sur la type de structure.
de plus, en admettant que la fonction à appeler soit un callback (une thread par exemple), la surchage ne résoud rien.

pour une thread, la fonction doit avoir une syntaxe précisée.
pour la SDL par exemple:
SDL_Thread *SDL_CreateThread(int (*fn)(void *), void *data);

on remarque qu'il faut que la fonction passée en argument soit du type:
int nomDeLaThread(void *);

donc inutile à surcharger.

en balancant
int maThread(struct maStructure*);
SDL_CreateThread(maThread, NULL);

il y a de bonne chance que ça ne compile ou ne link pas

[Laurent Gomila]

J'ai bien sûr supposé d'après ce qui a été dit que c'est notre ami qui concevait et codait ce mécanisme, s'il doit juste utiliser une fonction existante alors le débat est clos.

[swirtel]

Si ce thread est fini, peut-on le mettre en tant que "RESOLU" ?

Merci