Comment le mauvais est à utiliser void pointeur dans std::vector déclaration?

J'ai deux classes différentes, comme ci-dessous:

class text
{ };

class element
{ };

Et je veux les stocker dans le class node:

template <typename T>
class node
{
    T cargo;

    std::vector<void*> children;

    node(T cargo) : cargo(cargo)
    { };

    void add_child(T node)
    {
        this->children.push_back((void*) node);
    }
}

Je voudrais donc appeler le nœud de cette façon, le stockage, text et element's:

element div;
text msg;

node<element> wrapper(div);

wrapper.add_child(msg);

MODIFIER: Pour récupérer le contenu-je utiliser T typedef type; et convertir vide pointeur vers (type*).

Je sais que c'est pas très élégant ni fonctionnels, mais je ne peux pas comprendre ce qui est la façon correcte de le faire. Alors merci de me dire si cela est pratiquement acceptable et si elle n'est pas, comment le faire de manière appropriée.

Merci d'avance!

Que diriez-vous, tu sais... une classe de base?
La remarque ci-dessus: à moins que T est une primitive ou de type pointeur, il est peu probable qu'elle s'adapte à la taille d'un void*. Vous pourriez vouloir: add_child(T* node) ... push_back((void*)nœud); au lieu de cela.

InformationsquelleAutor Rizo | 2010-10-21

c++vector void

6
```
#include <vector>
using namespace std;

class Element {};
class Text {};
class Nothing {};

class Node
{
private:
    vector< Node* >     children_;
protected:
    Node() {}
public:
    void add( Node* p ) { children_.push_back( p ); }
    virtual ~Node() {}
};

template< class Cargo >
class CargoNode
    : public Node
{
private:
    Cargo   cargo_;
public:
    CargoNode(): cargo_() {}
};

typedef CargoNode< Element >    ElementNode;
typedef CargoNode< Text >       TextNode;
typedef CargoNode< Nothing >    RootNode;

int main()
{
    RootNode*   root    = new RootNode;

    root->add( new ElementNode );
    root->add( new ElementNode );
    root->add( new TextNode );
    root->add( new ElementNode );   
    //Etc.
}
```
Cheers & hth.,

PS: Erreur de vérification, de gestion de durée de vie, l'itération etc. omis dans cet exemple de code.
- Solution sympa. N'avais pas considéré comme le type de l'effacement.
- Je pense que tu veux dire "polymorphisme" 🙂 Au moins, la manière dont mon association circuits actuellement de résoudre les termes, boost::any est un exemple de type d'effacement. Vous avez connu une interface étroite à quelque chose, et derrière que vous rentrez un objet de presque n'importe quel type, sorte de câblage dans la colle par le biais de certains de template (génération de code qui fait un peu de coulée). Cheers,
- C'est plus propre et plus facile à utiliser, puis sur toutes les autres propositions! Je vous remercie.
- Vous avez raison, ce n'est pas tout à fait le type d'effacement (parce que les interfaces entre un Nœud et T ne sont pas les mêmes), mais je l'aime parce que vous n'avez pas eu à créer une fausse relation entre le texte et l'élément et tout le reste. Le dynamic_cast<>ing nécessaire pour obtenir les informations de retour de nouveau peut-être un peu douloureux, mais. Pas que le commutateur(ch.type), c'est mieux...
- Dragon: Est la dynamic_cast<>ing le seul moyen d'obtenir des informations de retour dans ce cas?
- Depuis, tous les objets sont stockés en tant que base de Nœud*s, puis une sorte de recherche sera nécessaire pour les convertir à la bonne CargoNode<> afin de récupérer leurs bagages. Je le fais ci-dessous par la réalisation d'un type autour, ce qui le fait à l'aide d'une hiérarchie de classe. Ils sont deux solutions différentes pour le même problème.
InformationsquelleAutor Cheers and hth. - Alf
1

Définir une base commune de classe pour element et text et puis add_child peut prendre un pointeur vers la classe de base, et le vecteur peut stocker des pointeurs vers la classe de base.
- Je dois dire que, bien qu'il puisse résoudre le problème, l'ajout de faux classes de base liés types ne se sent pas comme une très bonne solution pour moi.
- Puisqu'ils sont tous deux capables d'être des enfants de noeuds je pense qu'ils sont probablement liés à des types.
InformationsquelleAutor Douglas Leeder
1

Comment voulez-vous récupérer si vous faites cela? À partir d'un void* il n'y a aucun moyen de déterminer ce qui est réellement stocké sur l'adresse.

Edit:
Si vous êtes toujours en faire un moulage en T* alors vous pouvez simplement prendre T* en tant que paramètre.
- Oui, mais il peut en être déduit à partir d'autres paramètres, selon la logique du programme
- Cochez la case modifier.
- Vous souhaitez stocker les deux types ou seulement un seul? Pourquoi êtes-vous en prenant le paramètre de modèle alors? Veuillez expliquer davantage.
- Je veux les stocker à la fois. node's enfants vecteur doit être capable de stocker elements et text. Ma classe de conteneur est de garder registre des types sont ajoutés, puis les utilise pour restaurer les valeurs.
- Ensuite, vous ne devriez pas prendre T comme un paramètre de la add_child() méthode.
InformationsquelleAutor Let_Me_Be

Si votre conteneur valeur est limitée à un petit nombre de types, vous pouvez obtenir ce à l'aide de boost::variant comme indiqué ici:

#include <vector>
#include <boost/variant.hpp>

using namespace std;

class text
{ };

class element
{ };

template <typename T>
class node
{
    T cargo;

    static std::vector<boost::variant<text, element>> children;

    node(const T& cargo) : cargo(cargo)
    { };

    void add_child(const T& node)
    {
        children.push_back(boost::variant<text, element>(node));
    }
};

J'ai pris la liberté de proposer un couple de d'autres mods - utilisation const de référence au lieu de passer par valeur sur node constructeur et add_child; le récipient children statique, comme je ne pense pas que cela a du sens pour chaque node<T> d'avoir son propre conteneur. Verrouillage serait nécessaire pour multithread utilisation de add_child dans ce cas. Ces commentaires s'appliquent à savoir si vous pouvez utiliser Boost ou pas dans votre solution finale.

Vous pouvez effectuer des opérations sur les vector éléments en utilisant soit get ou static_visitor, ce dernier est préférable, car vous pouvez faire de ce générique, comme le montre ici. Un exemple de vector itération analogue à ce que vous pouvez utiliser pour cette solution:

class times_two_generic
    : public boost::static_visitor<>
{
public:

    template <typename T>
    void operator()( T & operand ) const
    {
        operand += operand;
        cout << operand << endl;
    }

};

std::vector< boost::variant<int, std::string> > vec;
vec.push_back( 21 );
vec.push_back( "hello " );

times_two_generic visitor;
std::for_each(
      vec.begin(), vec.end()
   , boost::apply_visitor(visitor)
   );

De sortie est:

42

bonjour bonjour

InformationsquelleAutor Steve Townsend

0

Tout d'abord, il n'y a pas une telle chose comme "mauvais" pour utiliser un pointeur void. Oubliez toutes les conventions et bla-blas, et faire ce qui est le plus approprié pour votre cas.

Maintenant, en vous cas précis, si il n'y a aucun lien entre ces deux catégories, vous pouvez déclarer une classe de base, de sorte que ces deux-là vont en hériter. Ensuite, vous pouvez déclarer le vecteur d'un pointeur de classe de base.
- Peut le node être elle-même la classe de base pour element sna text? Pourriez-vous, s'il vous plaît, montrez un rapide exemple de code?
InformationsquelleAutor valdo

Vous devez vous connecter pour publier un commentaire.