mot clé union (RPC)

Certaines fonctionnalités du langage C, telles que les unions, nécessitent des mots clés MIDL spéciaux pour prendre en charge leur utilisation dans les appels de procédure distante. Une union dans le langage C est une variable qui contient des objets de différents types et tailles. Le développeur crée généralement une variable pour suivre les types stockés dans l’union. Pour fonctionner correctement dans un environnement distribué, la variable qui indique le type de l’union ou le discriminant, doit également être disponible pour l’ordinateur distant. MIDL fournit les mots clés [switch_type] et [switch_is] pour identifier le type et le nom discriminants.

MIDL exige que le discriminant soit transmis avec l’union de deux façons :

• L’union et le discriminant doivent être fournis en tant que paramètres.
• L’union et le discriminant doivent être empaquetés dans une structure.

Deux types fondamentaux de syndicats discriminatoires sont fournis par MIDL : nonencapsulated_union et encapsulated_union. Le discriminant d’une union non-encapsulée est un autre paramètre si l’union est un paramètre. Il s’agit d’un autre champ si l’union est un champ d’une structure. La définition d’une union encapsulée est transformée en une définition de structure dont le premier champ est le discriminant et dont les deuxième et dernier champs sont l’union. L’exemple suivant montre comment fournir l’union et le discriminant en tant que paramètres :

typedef [switch_type(short)] union 
{
    [case(0)]    short     sVal;
    [case(1)]    float     fVal;
    [case(2)]    char      chVal;
    [default]    ;
} DISCRIM_UNION_PARAM_TYPE;
 
short UnionParamProc(
    [in, switch_is(sUtype)] DISCRIM_UNION_PARAM_TYPE Union,
    [in] short sUtype);

L’union de l’exemple précédent peut contenir une valeur unique : courte, flottante ou char. La définition de type de l’union inclut l’attribut MIDL switch_type qui spécifie le type du discriminant. Ici, [switch_type(short)] spécifie que le discriminant est de type court. Le commutateur doit être un type entier.

Si l’union est membre d’une structure, le discriminant doit être membre de la même structure. Si l’union est un paramètre, le discriminant doit être un autre paramètre. Le prototype de la fonction UnionParamProc dans l’exemple précédent montre le sUtype discriminant comme dernier paramètre de l’appel. (Le discriminant peut apparaître à n’importe quelle position dans l’appel.) Le type du paramètre spécifié dans le [switch_is] attribut doit correspondre au type spécifié dans l’attribut [switch_type].

L’exemple suivant illustre l’utilisation d’une seule structure qui empaquette le discriminant avec l’union :

typedef struct 
{
    short utype;  /* discriminant can precede or follow union */
    [switch_is(utype)] union 
    {
       [case(0)]   short     sVal;
       [case(1)]   float     fVal;
       [case(2)]   char      chVal;
       [default]   ;
    } u;
} DISCRIM_UNION_STRUCT_TYPE;
 
short UnionStructProc(
    [in] DISCRIM_UNION_STRUCT_TYPE u1);

Le compilateur MICROSOFT RPC MIDL autorise les déclarations d’union en dehors de constructions typedef. Cette fonctionnalité est une extension d’IDL DCE. Pour plus d’informations, consultez union.