... avec le constructeur sont pas autorisés dans l'union de problème

J'ai désespérément besoin de trouver une solution pour le problème suivant:

namespace test
{
    template <int param = 0> struct Flags
    {
        int _flags;

        Flags()
        {
            _flags = 0;
        }

        Flags(int flags)
        {
            _flags = flags;
        }

        void init()
        {

        }
    };

    union example
    {
        struct
        {
            union
            {
                struct
                {
                    Flags<4096> f;
                }p1; //error: member 'test::example::<anonymous struct>::<anonymous union>::<anonymous struct> test::example::<anonymous struct>::<anonymous union>::p1' with constructor not allowed in union

                struct 
                {
                    Flags<16384> ff;
                }p2; //error: member 'test::example::<anonymous struct>::<anonymous union>::<anonymous struct> test::example::<anonymous struct>::<anonymous union>::p2' with constructor not allowed in union
            }parts;

            byte bytes[8];
        }data;

        int data1;
        int data2;
    }
}

C'est frustrant que si je l'ajout de balises à p1 et p2 les structures, le code compile, mais le f & ff les membres ne seraient pas accessibles:

...
struct p1
{
    Flags<4096> f;
};

struct p2
{
    Flags<4096> ff;
};
...

void test()
{
    example ex;
    ex.data.bytes[0] = 0; //Ok
    ex.data.parts.p1.f.init(); //error: invalid use of 'struct test::example::<anonymous struct>::<anonymous union>::p1'
}

Est-il possible de faire ce travail en quelque sorte?

OriginalL'auteur Ryan | 2011-05-16

  1. 9

    @Sla dit, l'union ne peut se définir non-POD en tant que membre de données, il existe une alternative. Vous pouvez toujours définir un pointeur vers le non-POD que des données sur les membres de l'union.

    C'est donc admis:

    union
{
   struct
   {
      Flags<4096> *pf; //pointer to non-POD
   }p1;
   struct 
   {
      Flags<16384> *pff; //pointer to non-POD
   }p2;
}parts;

    Mais alors Coup de pouce.Variante est une meilleure alternative.

    Merci beaucoup les gars!

    OriginalL'auteur Nawaz

  2. 7

    Actuelle de la norme C++ ne permet pas aux non-POD types à l'intérieur des syndicats. Par conséquent, vous obtenez cette erreur de compilation de gcc.

    Au lieu d'utiliser C syndicats, vous devez utiliser boost::variant. De vérifier la doccumentation ici.

    À ajouter à ce qui précède:

    La nouvelle norme C++ (C++0x) ajoute une nouvelle fonctionnalité appelée comme Sans Restriction Des Syndicats, qui prend en charge le stockage non-POD types à un Syndicat.

    C++ comittee aime les points d'exclamation... Ce qui est un point à ne pas autoriser la non-pod types?

    OriginalL'auteur Alok Save

  3. 0

    Norme C++ 2003 ne permet pas ceci (à partir de la Norme 9.5):

    Un objet d'une classe avec un
    non-trivial constructeur (12.1), un
    non-trivial constructeur de copie (12.8), un
    non-trivial destructeur (12.4), ou un
    non-trivial copie opérateur d'affectation
    (13.5.3, 12.8) ne peut être membre d'un
    de l'union, ni d'un tableau de ces
    objets.

    Mais le C++0x, il permet, cependant, vous devez définir votre propre constructeur, car le constructeur par défaut sera déclaré comme étant supprimés si vous ne définissez pas de votre propre.

    De N3291 9.5:

    Si une non-donnée membre statique d'une
    l'union a un non-trivial par défaut
    constructeur (12.1), le constructeur de copie
    (12.8), constructeur de déplacement (12.8), copie
    opérateur d'affectation (12.8), de les déplacer
    opérateur d'affectation (12.8), ou
    destructeur (12.4), la
    fonction membre de l'union doit être
    fourni par l'utilisateur ou il sera implicitement
    supprimé (8.4.3) pour l'union.

    D'autres personnes ont suggéré coup de pouce.La variante. Pour une solution simple, il suffit de retirer le constructeur de Drapeau de la classe. Si vous avez besoin de l'initialiser manuellement à chaque fois que l'initialisation de l'objet de l'union, il ne sera pas confus, car l'union est essentiellement un C fonctionnalité.

    OriginalL'auteur user534498