Questions sur le vecteur, l'union et les pointeurs en C++

Question

Les questions que j'ai ne sont PAS des questions de devoirs, mais je considère utiliser ces concepts dans mon devoir. Le contexte, si cela peut aider, est comme ceci: j'ai besoin de suivre plusieurs instances syndicales et elles appartiennent à ma propre union dans l'une de mes propres classes en tant que variables de classe. (Note: le nombre d'instances syndicales est inconnu, donc je ne peux pas avoir juste un nombre fixe d'instances syndicales

1. Q1:. Si j'ai un syndicat, dire MyUnion, et de nombreux cas de cette union, puis-je les mettre ensuite dans un vecteur comme

   vector<union MyUnion> myVector(10); 
   

2. Q2: est-il valide d'avoir un pointeur de union comme

   union MyUnion *myUnionPtr = new union myUnion; 
   

?

3. Q3: J'envisage d'utiliser un vecteur de pointeurs de syndicat dans mon implémentation , est ce concept correct? Aussi, est-ce une approche normale en C++? Ai-je besoin de repenser à mon design?

Answer 1

1. Si le syndicat est CopyConstructable et assignable, il répond aux exigences de std :: vector.
   • Oui: MyUnion* ptr = new MyUnion();
   • Un conteneur de pointeurs fonctionne dans certaines situations, mais si vous voulez un conteneur de posséder pointeurs, regardez Boost de ptr_* containers. Cependant, ici, il semble que vous auriez soit un conteneur de non-pointeurs ou un conteneur de pointeurs non propriétaires, dont l'un est bien et commun pour le vecteur.

---

Tous les types sont, par défaut, à la fois CopyConstructable et assignable. ("Copyable" est utilisé pour signifier l'union de ces concepts, cependant la norme les spécifie individuellement.) C'est parce que copy ctors et op = sont ajoutés aux classes (les unions sont un type de classe) sauf dans certaines circonstances. Il ya quelques references en ligne, mais je ne connais pas un seul, disponible gratuitement en ligne, qui les énonce.

Vous devez sortir de votre chemin pour l'empêcher, comme:

• faire la copie cteur ou op = non publique
• faire la copie cteur ou op = prendre un non-const la référence
• envoyer le type de classe d'un élément non-CopyConstructable ou non affectable

Exemple:

union CopyableUnion { 
    int n; 
    char c; 
    double d; 
}; 

union NonCopyableUnion { 
    int n; 
    char c; 
    double d; 

    NonCopyableUnion() {} // required, because any user-defined ctor, 
    // such as the private copy ctor below, prevents the supplied 
    // default ctor 

private: 
    NonCopyableUnion(NonCopyableUnion const&); 
    NonCopyableUnion& operator=(NonCopyableUnion const&); 
}; 

int main() { 
    CopyableUnion a; 
    CopyableUnion b = a; // fine, uses copy ctor 
    b = a; // fine, uses op= 

    NonCopyableUnion c; 
    NonCopyableUnion d = c; // compile error (copy ctor) 
    d = c; // compile error (op=) 

    return 0; 
} 

---

Note: Et juste parce que quelque chose est Copiable, ne signifie pas qu'il fait ce que vous voulez!Exemple:

struct A { 
    int* p; 

    A() : p(new int()) {} 

    // the provided copy ctor does this: 
    //A(A const& other) : p(other.p) {} 
    // which is known as "member-wise" copying 

    ~A() { delete p; } 
}; 

int main() { 
    A a; 
    { 
    A b = a; 
    assert(b.p == a.p); // this is a problem! 
    } // because when 'b' is destroyed, it deletes the same pointer 
    // as 'a' holds 

    return 0; // and now you have Undefined Behavior when 
    // ~A tries to delete it again 
} 

La même chose est vraie pour les syndicats, bien sûr. Le correctif applique également, bien que, ainsi:

struct A { 
    int* p; 

    A() : p(new int()) {} 

    A(A const& other) : p(new int(*other.p)) {} 

    ~A() { delete p; } 
}; 

(Si vous avez repéré, oui, A a un problème si vous essayez toujours d'utiliser op =, exactement de la même manière comme il l'avait à l'origine avec la copie ctor.)