Coup de pouce.Tout se type d'original

J'ai besoin de jeter un any variable d'un type original.
J'ai besoin pour ce faire:

int i = 10;
any a(i);
int& i2 = any_cast<int &>(a);

Mais je veux que le type de magasins dans any variable. Et j'écris cela:

int i = 10;
any a(i);
a::type_value& i2 = any_cast<a::type_value &>(a); //there is no actually type_value

Comment puis-je faire quelque chose comme ça? Ou comment puis-je extraire le type de document de la any variable? Coup de pouce.la variante est pratique.

Si je ne peux pas le faire, alors j'ai une autre question de ce que C++ techniques et des bibliothèques de stocker et d'obtenir le type au travers d'une fonction pour résoudre ce problème?

Il vous suffit de pas faire cela avec Boost.Tout, donc, à l'aide de coup de pouce.Variante au lieu de cela va être la base de la réponse.
Pourquoi avez-vous besoin de faire cela?

OriginalL'auteur Kron | 2012-02-02

  1. 15

    C++ est un statiquement tapé la langue. Le type d'un boost::any est un runtime valeur; toute particulière any pouviez avoir n'importe quel type. C'est un peu le point.

    Il n'y a pas de any::type_value, parce que ce serait être un moment de la compilation valeur. Et any est un moteur d'exécution de construire.

    Considérez ceci:

    void TakeAnAny(boost::any a)
{
  a::type_value& i2 = any_cast<a::type_value &>(a);
}

    Ce type est any::type_value? Il est légal de faire appel TakeAnAny avec pratiquement tout type. Il n'y a pas qu'un seul type de compilation que any::type_value pourrait réduire. Et par conséquent, il n'existe aucun moyen pour le compilateur de déterminer un type. Depuis C++ est statiquement typé, vous êtes arrosé.

    Le but ultime de tout type d'effacement. J'ai une certaine valeur. Et je veux passer que pour une autre fonction. Ce processus va se poursuivre à travers plusieurs couches de communication. Mais je n'ai pas forcément envie de toutes ces différentes couches de savoir exactement quel type que j'utilise. J'ai seulement besoin de moi et de ma destination pour connaître le type. Si vous le coller dans un any et vous êtes fine. Tout le monde ne voit que la any, et vous savez ce qu'il contient.

    Ce processus ne fonctionne que parce que à la fois la source et la destination de savoir quel est le véritable type de la valeur. Si vous ne connaissez pas le type, alors vous ne devriez pas être à l'aide de any. Le but de any est pas une fonction s'asseoir et de le jeter dans un tas de types possibles (c'est ce que boost::variant est pour). Le but est d'effacer le type à partir d'une fonction de signature.

    Cela permet des choses comme générique de messages et de signaux. Vous vous inscrivez en quelques gestionnaire d'événements avec un système. Vous feu un événement qui prend un any en tant que paramètre. La personne qui déclenche l'événement sait que le "Clic de souris" événement prend toujours un vec2 comme paramètre. Ainsi, chaque "Clic de souris" gestionnaire de il jette à un vec2. La "Touche" de l'événement serait peut-être passer un int32_t. Donc, ces gestionnaires de voter pour elle à ce type. Et ainsi de suite. Tout le monde sait de quel type il faut effectivement.

    Cette habitude d'être fait avec void*. Le problème, c'est que vous avez des questions relatives à la propriété (any est une valeur, alors que void* est un pointeur). Aussi, un void* est donc de type effacé qu'il n'y a aucun moyen de vérifier pour voir si votre distribution est correcte. any est vraiment juste un type&valeur sûre void*; il vous empêche de casting pour le mal type.

    Vous ne voulez pas vraiment any. Votre cas d'utilisation ne semble pas vouloir variant. Ce que vous semblez vouloir, c'est un modèle. C'est un autre genre de chose, et il vous laisser faire ce que vous voulez vraiment: une fonction qui peut utiliser n'importe quel type particulier, tout en étant en mesure de savoir exactement ce que le type est.

    Bien sûr, les modèles ont leurs propres limites.

    OriginalL'auteur Nicol Bolas

  2. 1

    Vous pouvez utiliser une carte de std::type_info à std::function<void(boost::any const&)> objet de traiter avec des types que vous connaissez et que vous souhaitez traiter: vous recherchez l'entrée dans la carte à l'aide de a.type() et d'appeler la fonction correspondante qui permettrait de savoir comment faire face à l'argument.

    Si on est conscient des types qu'ils vont faire face, alors pourquoi aurait-on utiliser Boost.Tout au lieu de la Stimuler.Variante en premier lieu?
    Il semble un simple type de transmettre. Aussi, il peut y avoir des interfaces qui prennent boost::any comme arguments et éventuellement appeler une fonction où la boost::any est rendu dans une certaine forme. Par exemple, il semble que la fixation d'un boost::any à un objet de tenir arbitraire de l'information est une chose raisonnable et l'utilisateur de la classe peut très bien savoir quels types il peut fixer.
    Compte tenu de scénario ensuite, je suis d'accord que boost::any<> peut être appropriée; après tout, la bibliothèque n'existent pour une raison. Mais de toute façon je doute que l'OP est dans ce scénario, et j'ai toujours le vote pour Boost.Variante à moins que l'OP a une raison particulière qui n'est pas faisable. ;-]

    OriginalL'auteur Dietmar Kühl