Exemple simple avec des modèles

Question

Ceci est une question simple, et je suis sûr qu'il a déjà été répondu mais je n'arrive pas à trouver une bonne réponse.

J'ai une classe, Point

template<class T> 
Point{ 
\\code 
} 

... et maintenant je veux un vecteur de points, dont certains ont T sous forme d'entier qui ont T en double. Je veux écrire quelque chose comme

template<class T> 
std::vector<Point<T> > points; 

Mais, hélas, cela ne compile pas avec l'erreur « attendu expression primaire avant« modèle ». Je n'ai pas été capable de jouer avec ce code pour le faire fonctionner. Il est également important que les points soient dans la classe principale, donc je ne peux pas coller la déclaration de modèle en dehors de la fonction.

Si quelqu'un pouvait me diriger vers une solution, je serais très obligé.

Merci.

Answer 1

Si votre objectif est d'avoir un vector qui contient à la fois Point<int> et Point<double>, vous pouvez utiliser Boost Variant.

typedef boost::variant<Point<int>, Point<double> > VariantPoint; 

Puis:

std::vector<VariantPoint> my_vector; 

my_vector.push_back(Point<int>(1, 0)); 
my_vector.push_back(Point<double>(1.5f, 2.0f)); 

fonctionnera. Notez que pour inspecter les éléments par la suite, vous devrez probablement utiliser le visitor pattern tel que documenté here.

Si votre objectif est d'avoir différents types de vecteurs qui ne peut contenir qu'un seul type de Point, vous pouvez utiliser:

template<typename T> using PointVector = std::vector<Point<T>>; // C++11 

// Now you can write: 
PointVector<int> my_vector; 

// Which is equivalent to: 
std::vector<Point<int>> my_vector; 

Ou, si 11 C++ est pas une option:

template<typename T> struct PointVector 
{ 
    typedef std::vector<Point<T> > Type; 
} 

Puis:

PointVector<int>::Type my_vector; 

Answer 2

Pour obtenir un seul type de vecteur, j'utiliser l'héritage:Remarque: l'héritage est juste un mécanisme permettant d'obtenir l'équivalent d'un typedef de modèle. Cela signifie que PointVector ne doit contenir aucun membre de données ni aucune fonction virtuelle. Cependant, la suggestion de @ ereOn est préférée, et est discutée dans la réponse à this question.

L'ancienne façon de réaliser une variante serait d'utiliser une union.

class IntOrDouble { 
    union { 
     int i; 
     double d; 
    }; 
    bool is_int; 
    bool is_double; 
public: 
    IntOrDouble() : is_int(false), is_double(false) {} 
    IntOrDouble (int x) : is_int(true), is_double(false) { i = x; } 
    IntOrDouble (double x) : is_int(false), is_double(true) { d = x; } 
    int operator = (int x) { 
     is_int = true; 
     is_double = false; 
     return i = x; 
    }; 
    double operator = (double x) { 
     is_int = false; 
     is_double = true; 
     return d = x; 
    }; 
    operator int() const { 
     if (is_int) return i; 
     if (is_double) return d; 
     return 0; 
    } 
    operator double() const { 
     if (is_double) return d; 
     if (is_int) return i; 
     return 0; 
    } 
}; 
typedef std::vector< Point<IntOrDouble> > PointVector; 

Mais tout cela semble un peu exagéré dans ce cas d'utilisation. Je voudrais juste utiliser des vecteurs de double tout autour, à moins que la mémoire soit vraiment serrée.