Comment utiliser c union imbriqué dans struct sans nom

Je suis en train de travailler sur le soi-disant Hotspot projet open source, et à la recherche à la mise en œuvre, j'ai trouvé un méchant imbriquée union struct le regarder de cette manière:

typedef struct RC_model_t_st
{
    union
    {
        struct block_model_t_st *block;
        struct grid_model_t_st *grid;
    };
    /* block model or grid model    */
    int type;
    thermal_config_t *config;
}RC_model_t;

Autant que je suis au courant en C/C++ que l'union fait la unaccesible. Alors, comment quelqu'un peut faire usage de l'union déclarée de la manière et dans quel but?

Merci!

source d'informationauteur zwx

  1. -4

    tout d'abord, je tiens à dire que Une union, est une collection de variables de types différents, tout comme une structure. Cependant, avec les syndicats, vous ne pouvez stocker des informations dans un seul domaine à la fois.

    Les syndicats sont utilisés essentiellement pour la mémoire enregistrement & sa taille est égale à la plus grande des membres de l'union.

    Et pour l'accès aux données des champs d'une union, l'utilisation de l'opérateur point(.) tout comme vous le feriez pour une structure et expliqué par @Atmocreations. Lorsqu'une valeur est affectée à l'un des membres, l'autre membre(s) se faire fouetter car ils partagent la même mémoire.

    comme un exemple où les syndicats peut être utile, c'est 

    union time    
        {
        long time_in_sec;
        double time_in_mili_sec;
        }mytime;

    ....
    L'union ci-dessus peuvent être utilisées pour stocker l'heure actuelle (en secondes) temps de maintien précis à la seconde. Ou il pourrait être utilisé pour maintenir l'heure exacte à une milliseconde. Sans doute il ya des moments où vous souhaitez que l'un ou l'autre, mais pas les deux. Cette déclaration devrait vous être familier. C'est la même que la structure de la définition, mais avec le mot-clé union au lieu de la struct.

    pour plus d'info http://msdn.microsoft.com/en-us/library/5dxy4b7b(v=vs. 80).aspx

  2. 20

    C'est un anonyme de l'union. En C++, comme par [la classe.de l'union], paragraphe 5:

    Pour le but de la recherche d'un nom, d'après l'anonyme de l'union définition,
    les membres de l'anonyme de l'union sont considérés comme ayant été définis
    dans le champ d'application dans lequel l'anonymat de l'union est déclaré

    Cela signifie que vous pouvez accéder à ses membres, comme s'ils étaient des membres de RC_model_t_st.

  3. 8

    Sans en être sûr et sans avoir essayé:

    L'union elle-même n'est pas accessible, mais ses membres sont.

    Par conséquent, vous devriez être en mesure de faire référence à obj.block et obj.grid

  4. 3

    Ce code ici (https://gist.github.com/klange/4042963) montre comment l'accès anonyme syndicats à l'intérieur de struct. Vous venez d'accéder aux membres de imbriquée de l'union que s'ils sont membres de la structure.

    typedef struct {
    union {
        char * company;
        char * school;
        char * project;
    };
    union {
        char * location;
        char * url;
    };
    union {
        char * title;
        char * program;
    };

    time_t started;
    time_t left;

    char * description[];
} thing_t;

typedef thing_t job_t;

job_t yelp = {
    .company  = "Yelp, Inc.",
    .location = "San Francisco, CA",
    .title    = "Software Engineer, i18n",
    .started  = 1339977600,
    .left     = CURRENT,
    .description = {
        "Developed several internal tools and libraries",
        "Provided critical input and design work for Yelp's launch in Japan",
        NULL
    }
};
  5. 2

    Noms déclarés dans l'anonymat de l'union sont utilisés directement, comme les non-membre de variables.
    Une bonne raison de le faire est d'économiser de la mémoire.

    #include <iostream>

int main(int argc, char **argv) {
   union {
      double first;
      double second;
   };

   first = 10.001;
   second = 3.141592;
   std::cout << first << " " << second << std::endl;

   first = 10.002;
   std::cout << first << " " << second << std::endl;
}
  6. 2

    De donner des précisions sur la réponse fournie par Angew citant la norme concernant les anonymes, les syndicats et les structures, j'ai pensé à fournir un exemple de code source C avec la sortie générée par cet exemple montrant comment les valeurs sont alloués dans un struct et un union composé de struct et union composants.

    La norme citée par Angew est:

    Pour le but de la recherche d'un nom, d'après l'anonyme de l'union définition,
    les membres de l'anonyme de l'union sont considérés comme ayant été définis
    dans le champ d'application dans lequel l'anonymat de l'union est déclarée.

    Le code source d'un struct composé de nommé et anonyme, les structures et les syndicats se présente comme suit. C'est à l'aide de Visual Studio 2005 et de la #pragma (pack, 1) est utilisé pour aligner le tout sur un char limite dans l'ordre pour qu'il y ait pas de trous de mémoire. Il y a aussi un simple Préprocesseur C macro définie pour rendre la sortie plus lisible et plus facile à coder.

    typedef unsigned char UCHAR;
//use of Microsoft Visual Studio pragma to force char alignment for the struct.
#pragma pack(push, 1)
const struct {
union {
const UCHAR myArray[];  //this array shares memory with struct following
struct {
const UCHAR iOne;
const UCHAR iTwo;
const UCHAR iThree;
};  //anonymous struct accessed by specifying Things.
};      //anonymous union accessed by specifying Things.
// const UCHAR myArray[];   //will cause error - "error C2020: 'myArray' : 'struct' member redefinition"
union {
const UCHAR myArray[];  //this array shares memory with struct following
struct {
const UCHAR iOne;
const UCHAR iTwo;
const UCHAR iThree;
} s;    //named struct accessed by specifying Things.u.s
} u;        //named union accessed by specifying Things.u
} Things = {1, 2, 4, 8, 9, 10, 22, 23, 24, 25};
#pragma pack(pop)
//a little helper macro to make the output easier to code.
#define PRINTF_VAL(x) printf ("%s %d \n", #x, x)
int itSelf (UCHAR iMask)
{
int iMatch = -1;
int jj = 0;
jj = Things.myArray[0]; PRINTF_VAL(Things.myArray[0]);
jj = Things.myArray[1]; PRINTF_VAL(Things.myArray[1]);
jj = Things.myArray[2]; PRINTF_VAL(Things.myArray[2]);
jj = Things.myArray[3]; PRINTF_VAL(Things.myArray[3]);
jj = Things.myArray[4]; PRINTF_VAL(Things.myArray[4]);
jj = Things.iOne; PRINTF_VAL(Things.iOne);
jj = Things.iTwo; PRINTF_VAL(Things.iTwo);
jj = Things.iThree; PRINTF_VAL(Things.iThree);
jj = Things.u.myArray[0]; PRINTF_VAL(Things.u.myArray[0]);
jj = Things.u.myArray[1]; PRINTF_VAL(Things.u.myArray[1]);
jj = Things.u.myArray[2]; PRINTF_VAL(Things.u.myArray[2]);
jj = Things.u.myArray[3]; PRINTF_VAL(Things.u.myArray[3]);
jj = Things.u.myArray[4]; PRINTF_VAL(Things.u.myArray[4]);
jj = Things.u.s.iOne; PRINTF_VAL(Things.u.s.iOne);
jj = Things.u.s.iTwo; PRINTF_VAL(Things.u.s.iTwo);
jj = Things.u.s.iThree; PRINTF_VAL(Things.u.s.iThree);
return iMatch + 1;
}

    La sortie générée par cette fonction ressemble:

    Things.myArray[0] 1
Things.myArray[1] 2
Things.myArray[2] 4
Things.myArray[3] 8
Things.myArray[4] 9
Things.iOne 1
Things.iTwo 2
Things.iThree 4
Things.u.myArray[0] 8
Things.u.myArray[1] 9
Things.u.myArray[2] 10
Things.u.myArray[3] 22
Things.u.myArray[4] 23
Things.u.s.iOne 8
Things.u.s.iTwo 9
Things.u.s.iThree 10

    La sortie montre le chevauchement entre les différentes composantes de la principale structThings causés par l'utilisation des syndicats. Vous pouvez également voir comment les composants de l'anonyme struct et union sont référencés par rapport à ceux des composants de l'nommé struct et union.

    Aussi juste pour le fun j'ai essayé d'ajouter une définition de tableau de const UCHAR myArray[]; après l'anonyme union contenant const UCHAR myArray[]; pour voir ce qui allait se passer. Le compilateur se plaint avec une erreur de error C2020: 'myArray' : 'struct' member redefinition. L'ajout de commentaires dans les struct définition de Things ci-dessus. Cependant, depuis la seconde utilisation de const UCHAR myArray[]; est dans un union la compilation fonctionne parce que le deuxième utilisation est accessible en précisant le nom de l'union.