Discussion :

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

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

[dalfab]

Bonjour,

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

Code :

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

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

[foetus]

Solution 1 : il faut faire l'inverse 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 :

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

[Plotoner]

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

Merci aussi foetus, mais ta solution est (légèrement ) plus compliquée, en plus mes exigences sur le code m'empechent d'utiliser des malloc

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

[Mat.M]

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.