Héritage d’une liste de classes basées sur des modèles, lorsqu’il est fourni avec la liste des arguments de modèles

J’essaie d’écrire du code de métaprogrammation tel que:

L’inheritance d’une classe foo entraîne l’inheritance de la key, key, key, ...
L’approche la plus simple ne fonctionne pas, car vous ne pouvez pas hériter de la même classe vide plus d’une fois.
Manipuler la partie “…” n’est pas joli (puisqu’il s’agit de copier-pâtes), mais fonctionne.

Ok, alors voici la tentative:

 template struct char_if { typename THEN type; }; template struct char_if { typename ELSE type; }; class emptyClass {}; template class key { char getKey(){return c;} }; template class inheritFromAll { typename char_if<c0, key, emptyClass>::type valid; class inherit : valid , inheritFromAll::inherit {}; }; template class inheritFromAll { class inherit {}; }; template class whatINeedToDo : public inheritFromAll::inherit { bool success(){return true;} }; int main() { whatINeedToDo experiment; return 0; }

Au départ, je pouvais utiliser Boost :: Mpl pour le faire, mais honnêtement, je ne savais pas comment; Je ne pouvais pas imaginer comment vous feriez passer une list sans toujours savoir explicitement la partie ...

Je fais juste:

 template class key {};

ne fonctionne pas car si j’ai alors plus d’un paramètre 0 , j’essaie d’hériter deux fois de la même chose. (Si vous pouvez penser à une solution de contournement pour cela, cela fonctionnerait également).

Je n’ai pas non plus essayé les macros, car je pense les connaître moins que la métaprogrammation, elles pourraient donc constituer une solution.

Des idées?

Edit: j’ai une mauvaise solution. Je voudrais toujours une solution de méta-programmation, pour l’apprentissage, mais la mauvaise solution est la suivante:

 template class inheritFromMany : public key , public key , public key { }; template class inheritFromMany : key , key { };

Edit2: Ouaf, mais j’ai oublié une partie. Je dois passer une variable au constructeur de ” key ” – c’est la même chose dans tous les cas, mais c’est nécessaire.

Edit3: Adressage des commentaires:

Je ne m’attends pas à ce que l’utilisateur envoie le même caractère plus d’une fois. S’ils le faisaient, je voudrais seulement hériter de cette clé une fois – je veux dire, je suppose que je n’ai pas mentionné cela parce que vous ne pouvez pas faire cela? Pourquoi d’autres solutions plus simples ne fonctionnent-elles pas?
Le point réel de ceci est que la clé est un wrapper pour un comportement signal / slot (canal). Le canal conserve une liste de rappels, qui est en fait juste virtual key::callback . Ainsi, hériter d’une clé vous donne access au canal de cette clé, permet (ou vous oblige) de fournir un rappel. keyInput est alors un wrapper pour cela, vous n’avez donc pas besoin de key, key, key

Sans que vous ne disiez ce que vous voulez réellement réaliser, il s’agit d’un exercice essentiellement académique … mais voici comment vous pourriez utiliser MPL pour hériter de manière linéaire:

 template struct key { enum { value = T::value }; char getKey() { return value; } }; template struct derivator : mpl::inherit_linearly< Values , mpl::inherit< mpl::_1, key > >::type {}; // usage: typedef mpl::vector_c values; typedef derivator generated; // or: derivator< mpl::vector_c > derived;

Peut-être pourriez-vous préciser sur cette base ce dont vous avez besoin.

Je dois passer une variable au constructeur de ” key ” – c’est la même chose dans tous les cas, mais c’est nécessaire.

Voulez-vous dire que vous voulez transmettre un paramètre à tous les constructeurs via la chaîne d’inheritance? Ensuite, jetez un coup d’œil aux solutions à cette question .

Pour éviter mpl::vector_c dans l’interface visible, vous pouvez utiliser votre approche précédente et la construire en interne en insérant uniquement des valeurs non nulles:

 template struct push_char { typedef typename mpl::push_front >::type type; }; template struct push_char<0, S> { typedef S type; // don't insert if char is 0 }; template struct char_vector { // build the vector_c typedef typename push_char >::type>::type>::type type; }; template struct derivator : mpl::inherit_linearly< typename char_vector::type , mpl::inherit< mpl::_1, key > >::type {};