Comment combiner des modèles avec des enums en C++?

Il y a une énorme compilation en C++ langage de programmation qui offre un contrôle strict sur les types de données. Souvent on aurait moule son code avec un système de template pour atteindre la plupart des fonctionnalités adéquates tout en garantissant à l'intérieur de ce type correct de la préservation et de la flexibilité dans sa manipulation. Moins fréquemment, les énumérations sont utilisés à cette fin, puisqu'ils ont permis de définir explicitement les possibilités pour les données et n'ont aucun moyen direct pour vérifier l'exactitude des types.

Donc ce que nous avons sont des modèles qui permettent de fonctions et de classes pour fonctionner avec les types génériques sans être réécrit pour chacun; et les énumérations, en fournissant un droit d'utilisation de la types.

Est-il possible de définir une restriction de modèle de l'architecture d'une classe à l'aide d'un enum comme un modèle? Comment un templatized utilisation d'une méthode de enumed type et quand il pourrait être utile?

Ma dernière question est: comment faire pour lier les modèles et l'énumération des types et de les utiliser ensemble dans le résumé des données de conception?

Comme un exemple, supposons que vous essayez de créer un conteneur de données, vous vous attendez à avoir des types définis dans un enum au sein de votre classe:

template <typename T>
class element
{
public:
  enum type { text_type, widget_type, image_type };

  ...
private:
  type node_type;

};

Vous aussi défini chacun des types présents dans class element:

class text;
class widget;
class image;

Créer un élément, vous souhaitez spécifier son type de contenu (texte, widget ou l'image), de sorte que vous passer en argument de modèle.

if (node_type == text_type) do_something();

En Java vous avez List<? extends T> qui, implicitement, dit ce type de cours peut être utilisé comme paramètre de modèle. Peut-il être fait en C++ en utilisant les énumérations? Comment travailler avec enumed types de déclarations?

Question: je voudrais savoir comment faire pour limiter le comportement de modèles par enumed types pour s'assurer que seuls ceux-ci sont utilisés, et d'orienter le code d'utilisation traditionnelle de la façon de travailler avec les enums.

Qu'entendez-vous par "Est-il possible de définir une restriction de modèle de l'architecture d'une classe à l'aide d'un enum comme un modèle?"?
Est enum comportement en question en cascade de Java utilisation ?
vous devez préciser votre question. Comme posté c'est bien trop vague. Essayez de poster un peu de code pour montrer ce que vous essayez de faire
S'il vous plaît ajouter un potentiel de cas d'utilisation (en pseudo-code) de votre question.
Parlez-vous un équivalent à la Java List<? extends T> génériques paradigme?

OriginalL'auteur Rizo | 2010-10-19

c++enums language-features templates

6

Le type de traits idiome comme @UncleBens illustre est la manière habituelle de la résolution de ce problème.

Vous pouvez attacher des informations à des classes à l'aide de static const membres de l'entier ou de type énumération, en tant que bien.
```
#include <iostream>

enum color { red, green, blue };

struct x {
    static const color c = red;
};

template< color c >
struct thing;

template<>
struct thing< red > {
    thing() { std::cout << "red\n"; }
};

int main() {
    thing< x::c >();
}
```
je suppose que si cela pourrait être utilisé pour sélectionner un type de modèle . Par exemple à l'aide d'une matrice<floatType> => résultat dans un 4x4 float matrice, (et le type float est juste une valeur d'enum)
Vous pourriez certainement organiser pour qui, mais ne serait pas matrix< float, 4, 4 > être plus clair?
sûr:) tout simplement parce que dans mon cas, à l'aide enum fait de l'API beaucoup plus simple. J'ai seulement une quantité limitée de types de vecteurs (float2,float3,ubyte3) etc. ainsi, au lieu de checkin si ce type a longueur correcte je viens d'offrir enum pour les types I support

OriginalL'auteur Potatoswatter

Si vous n'avez pas besoin d'utiliser les énumérations, je crois que vous pourriez employer des techniques similaires à celles utilisées dans la bibliothèque standard pour catégoriser les itérateurs.

class text {};
class widget {};
class image {};

struct text_type_tag {};
struct widget_type_tag {};
struct image_type_tag {};

template <class T>
struct element_traits;

template <>
struct element_traits<text>
{
    typedef text_type_tag category;
};

template <>
struct element_traits<widget>
{
    typedef widget_type_tag category;
};

template <>
struct element_traits<image>
{
    typedef image_type_tag category;
};

//add specializations for any other type you want to categorize

//a template that only works with widget types
template <class Widget>
void foo_implementation(Widget w, widget_type_tag);

template <class Widget>
void foo(Widget w)
{
    foo_implementation(w, typename element_traits<Widget>::category());
}

int main()
{
    foo(widget());
    foo(10);  //error, element_traits not specialized for int (incomplete)
    foo(image()); //error, no matching call for foo_implementation(image, image_type_tag);
}

Une autre possibilité: la surcharge foo_implementation pour les autres catégories d'éléments.

OriginalL'auteur UncleBens

Vous devez vous connecter pour publier un commentaire.