Switch à l'intérieur d'une structure

Version imprimable

Bonjour à tous, je voudrais savoir si il est possible en C d'utiliser un switch à l'intérieur de la declaration d'une structure. Je m'explique : je voudrais une structure dont le premier member est un entier, et dont le second member depend de cet entier :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 typedef struct {...}MT1; typedef struct {...}MT2; typedef struct {...}MT3; typedef struct switch_struc { int entier; switch (entier) { case 1 : MT1 MT1; case 2 : MT2 MT2; case 3 : MT3 MT3; } }switch_struc;
Pensez vous que cela est realisable ? Merci d'avance !

Bonjour,

Un switch c'est du code, dans une structure on met des données. Ce que tu souhaites c'est une union.
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 typedef struct switch_struc { int entier; union { MT1 mt1; MT2 mt2; MT3 mt3; } u; } switch_struc; switch_struc sws; sws.entier = 1; sws.u.mt1 = ....

Solution 1 : il faut faire l'inverse :mrgreen: tu fais 3 structures et tu mets ton switch partout dans ton code.
Problème : beaucoups de copié-collé, maintenir X structures et pas générique du tout (une structure ne pas être remplacée facilement par une autre comme avec un pointeur/ polymorphisme)

Solution 2 : Solution générique, non compilée (patron de conception : usine (factory en anglais))

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
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
typedef enum e_generic_type {
    GENERIC_TYPE_MT1 = 0,
    GENERIC_TYPE_MT2,
    GENERIC_TYPE_MT3
} One_Generic_Type;
 
 
typedef struct s_type_generic {
    void* MTX;
 
    One_Generic_Type type;
} Type_Generic;
 
 
unsigned char type_generic_construct(Type_Generic** one_generic) {
    unsigned char ret;
 
    if (one_generic != NULL) {
        (*one_generic) = (Type_Generic*) malloc( sizeof(Type_Generic) );
 
        if (one_generic != NULL) {
            one_generic->MTX = NULL;
 
            ret = 1;
        } else {
            ret = 0;
        }
    } else {
        ret = 0;
    }
 
    return ret;
}
 
 
unsigned char type_generic_destruct(Type_Generic** one_generic) {
    unsigned char ret;
 
    if (one_generic != NULL) {
        if (one_generic->MTX != NULL) {
//          Maybe test the type to make more cleanups
            free(one_generic->MTX);
        }
 
        free( (*one_generic) );
        (*one_generic) = NULL;
 
        ret = 1;
    } else {
        ret = 0;
    }
 
    return ret;
}
 
 
unsigned char type_generic_factory(Type_Generic** one_generic, One_Generic_Type one_type) {
    unsigned char ret;
 
    if ( type_generic_construct(one_generic) ) {
        switch(one_type) {
        case GENERIC_TYPE_MT1: /* one_generic->MTX = malloc; */ one_generic->type = GENERIC_TYPE_MT1; ret = 1; break;
        case GENERIC_TYPE_MT2: /* one_generic->MTX = malloc; */ one_generic->type = GENERIC_TYPE_MT2; ret = 1; break;
        case GENERIC_TYPE_MT3: /* one_generic->MTX = malloc; */ one_generic->type = GENERIC_TYPE_MT3; ret = 1; break;
        default: type_generic_destruct( (*one_generic) ); ret = 0; break;
//      Or you can do a manual cleanup because the generic is just constructed
//      but you should maintain this case and you can lose extra works made by the fonction type_generic_destruct
//      default: free( (*one_generic) ); (*one_generic) = NULL; ret = 0; break;
        }
    } else {
        ret = 0;
    }
 
    return ret;
}

12/02/2018, 10h24
Plotoner

Merci beaucoup Dalfab, ça a l'air vraiment pas mal :D

Merci aussi foetus, mais ta solution est (légèrement :P) plus compliquée, en plus mes exigences sur le code m'empechent d'utiliser des malloc :?
12/02/2018, 14h39
Médinoc

C'est possible dans d'autres langages que le C (notamment le Microsoft Interface Definition Language) mais pas en C. Quand MIDL génère un source C, celui-ci contient des unions là où le fichier .idl contenait des switch.
12/02/2018, 20h29
Mat.M

Citation:

Envoyé par Plotoner

Bonjour à tous, je voudrais savoir si il est possible en C d'utiliser un switch à l'intérieur de la declaration d'une structure. Je m'explique : je voudrais une structure dont le premier member est un entier, et dont le second member depend de cet entier :

il faut pour cela utiliser un pointeur de fonction dans la structure et en foncton des alternatives possibles appeler la fonction adéquate.
Sinon ce n'est pas possible , une structure est un moule de données.