C++ std::map de modèle de valeurs de classe

Je suis d'essayer de déclarer un Row et un Column classe, avec les Row avoir un std::map avec des valeurs pointant vers basé sur un modèle Column. Quelque chose comme ceci:

template <typename T>
class DataType {
  private:
    T type;
};
template <typename T>
class Field {
  private:
    T value;
    DataType<T> value;
};
class Row {
  private:
    std::map<unsigned long,Field*> column;
};

Bien, je suppose, en principe, la Row classe ne devriez pas avoir de savoir quel type de Field (ou Column) nous aimerions utiliser, c'est à dire si c'est un Field<int> dans la colonne 1 ou qu'un Field<double> dans la colonne 2. Mais je ne sais pas quel est la syntaxe correcte pour la Row::column déclaration, ou si le std::map est limitée en ce sens, et je devrais être en utilisant quelque chose d'autre.

Je appretiate vous des suggestions et vous remercions à l'avance.

Alors, quelle est la question?
vous n'avez pas à transformer votre code en html. il suffit de le mettre comme il est, avec les 4 caractères de l'indentation.
<i>à Dave:</i> Ma question est: Puisque le Champ est basé sur un modèle, comment puis-je "raconte" la std::map que les valeurs sont "tout Terrain"? <i>à litb:</i> Merci pour la suggestion! 🙂

OriginalL'auteur jbatista | 2009-02-20

  1. 24

    Field seul n'est pas un type, mais un modèle qui peut générer une famille de types, tels que Field<int> et Field<double>. Tous ces champs ne sont pas liés, tels que l'on est en quelque sorte dérivé de l'autre, ou d'une telle. Donc, vous avez à établir une relation entre tous ces types générés. Une façon est d'utiliser une commune non-modèle de la classe de base:

    class FieldBase { };

template <typename T>
class Field : public FieldBase {
  private:
    T value;
    DataType<T> type;
};
class Row {
  private:
    std::map<unsigned long,FieldBase*> column;
};

    Et d'envisager l'utilisation de pointeur intelligent, au lieu de pointeur brut dans le code. De toute façon, maintenant, le problème est que le type d'informations est perdu - si vous pointez sur un Field<double> ou à un Field<int> ne sait pas plus et ne peuvent être détectés que par le maintien de certains de tri de type-drapeau dans la base qui est fixée par le basé sur un modèle dérivé de la classe ou en demandant RTTI à l'aide de

    dynamic_cast<Field<int>*>(field) != 0

    Mais c'est laid. Surtout parce que ce que vous voulez il ya une valeur sémantique. I. e, vous voulez être en mesure de copier votre ligne, et il serait de copier tous les champs. Et vous voulez obtenir un double lorsqu'un double est conservé, sans d'abord à l'aide de RTTI de pirater votre chemin vers le type dérivé.

    Une façon de le faire est d'utiliser une discrimination de l'union. C'est essentiellement une union pour certains types arbitraires et, en outre, un type-drapeau, qui stocke la valeur est actuellement stockés dans ce domaine (e.g si un double, int, ...). Par exemple:

    template <typename T>
class Field {
  private:
    T value;
    DataType<T> type;
};
class Row {
  private:
    std::map<unsigned long, 
             boost::variant< Field<int>, Field<double> > > 
      column;
};

    boost::variant fait tout le travail pour vous. Vous pouvez utiliser des visites à faire appel à un foncteur en utilisant le droit de surcharge. Jetez un oeil à son manuel

    OriginalL'auteur Johannes Schaub - litb

  2. 1
    1. Vous avez une erreur: vous avez à "valeur" membre dans le Champ (on devrait probablement être de "type").
    2. S'il vous plaît ne gardez pas cru pointeurs dans le plan de la valeur. Utilisation boost::shared_ptr.
    3. Aussi, vous devriez avoir une bonne raison pour écrire de telles classes où il y a beaucoup de DB/table de manipulation de code il y en a déjà qui vous pouvez probablement utiliser. Alors, si c'est possible, envisagez de l'aide de quelque chose d'existant et ne pas écrire votre propre table de code de traitement.

    Maintenant, pour répondre à votre question :), le Champ<> les classes peuvent hériter d'une classe de base commune qui est partagé par tous les types de données. De cette façon, un conteneur comme votre colonne de la carte peut garder les pointeurs (faire que partagé pointeurs) dérivés des objets qui sont des instances d'une classe template.

    1. Désolé, vous avez raison, je voulais dire: T avalue; Type<T> atype; 2. Je ne suis pas familier avec la bibliothèque Boost (je suppose que c'est ce dont vous parlez), mais je vais regarder, merci. 3. Pourriez-vous s'il vous plaît signaler une ou deux suggestions que je puisse voir?

    OriginalL'auteur Assaf Lavie

  3. 0

    Un Row< int, float, int> est vraiment différent de la Row<int, std::string>.
    Clairement, Row<int,float,int>.field<0> devrait être un Field<int> tout Row<int,float,int>.field<1> devrait être un Field<float>. Et Row<int,float,int>.field<3> est une erreur du compilateur.

    La façon la plus simple de le faire est d'utiliser Boost. Beaucoup de l'intelligence a été lancé par Loki (voir Modern C++ Design, par Andrei Alexandrescu) mais Stimuler est plus moderne et mieux pris en charge.

    Normalement, vous ne devriez pas effectuer une itération sur les champs - chaque domaine a son propre type. Mais vous le faites, vous serait en effet besoin d'un FieldBase. Si vous avez besoin d'une telle interface, il est probablement utile de stocker également les champs, en interne comme un boost::array<FieldBase, N> (c'est à dire Row<int,float,int> a un boost::array<FieldBase, 3>). Vous ne devriez jamais dynamic_cast que FieldBase*, cependant. C'est un moteur d'exécution de test, et vous savez toujours exactement T de chaque Field<T> au moment de la compilation.

    OriginalL'auteur MSalters