Nom de la variable de l'argument du modèle?

Question

Existe-t-il un moyen de générer le nom d'une variable dans une classe basée sur un argument template?

template<class T, (someconstruct) t> 

class Item { 
    public:   
     T t; 
}; 

Item<float, "Position"> myItem; 

myItem.Position = 0.123f; 

tel que ce que j'instancié est une variable de type T, avec l'identifiant t (où t est transmise par le programmeur, soit Position, nous avons donc un T appelé Position? Ou est-ce l'étirement de la modèle de méta-programmation de modèle un peu trop loin?: p

Answer 1

Non, vous ne pouvez pas réaliser cela avec des modèles.Les noms de variables (connus sous le nom «identificateurs») ne peuvent pas être manipulés par des modèles par programmation.C'est le preprocessor qui peut le faire.

Peu importe, cela semble être une mauvaise idée. Pourquoi voulez-vous voulez pour ce faire?

Answer 2

Non, pas avec cette syntaxe, mais vous pouvez créer une configuration similaire à ce que vous essayez de faire:

template < typename Field > 
struct field_value 
{ 
    typename Field::type value; 
}; 

template < typename Seq > 
struct funky_struct : boost::mpl::inherit_linearly 
    < 
    Seq 
    , boost::mpl::inherit 
    < 
     field_value< boost::mpl::placeholders::_2> 
    , boost::mpl::placeholders::_1 
    > 
    >::type 
{}; 

template < typename Field, typename Struct > 
typename Field::type & get(Struct & s) { return static_cast< field_value<Field>& >(s).value; } 

struct first_field { typedef int type; }; 
struct second_field { typedef char type; }; 

struct my_funky : funky_struct< boost::mpl::vector<first_field,second_field> > {}; 

... 
my_funky f; 
get<first_field>(f) = 23; 

Je laisse en permettant la construction non par défaut pour vous. En outre, avec une quantité mineure de travail cela peut être reflété et vous pouvez coller toute quantité d'informations utiles sur les champs à l'intérieur.

Answer 3

Quelque chose comme ce que vous voulez réaliser peut être accompli avec l'héritage. Autrement dit, la classe parente a le nom de la variable que vous voulez que votre modèle ait.

struct ItemNull {}; 

template <typename X, typename Y = ItemNull> 
class Item : public X, public Y {}; 

template <typename T> struct HasPosition { T Position; }; 
template <typename T> struct HasMomentum { T Momentum; }; 

Item< HasPosition<float> > myItem1; 
myItem1.Position = 0.123f; 

Item< HasPosition<float>, HasMomentum<float> > myItem2; 
myItem2.Position = 0.1f; 
myItem2.Momentum = 0.2f; 

Le second argument optionnel permet une composition, comme illustré sur myItem2. Pour ajouter un troisième champ, vous pouvez ajouter à la queue, ou d'étendre à l'avant:

template <typename T> struct HasName { T Name; }; 

Item < 
    HasPosition<float>, 
    Item< HasMomentum<float>, HasName<std::string> > 
> myItem3; 
myItem3.Position = 0.1f; 
myItem3.Momentum = 0.2f; 
myItem3.Name = "Adam"; 

Item < 
    Item < HasPosition<float>, HasMomentum<float> >, 
    HasName<std::string> 
> myItem4; 
myItem4.Position = 0.1f; 
myItem4.Momentum = 0.2f; 
myItem4.Name = "Adam"; 

Ma préférence personnelle est pour l'ex-des deux méthodes, parce que je trouve être une façon plus intuitive d'étendre au-delà de 3 champs. La syntaxe du modèle Item pourrait probablement être simplifiée en utilisant des arguments de modèle variadique. Les modèles Has... peuvent être générés par une machine ou une macro peut être créée pour rendre l'ajout de nouveaux champs une tâche relativement simple.

#define MAKE_HAS(X) template <typename T> struct Has##X { T X; } 

MAKE_HAS(Position); 
MAKE_HAS(Momentum); 
MAKE_HAS(Name);