C ++ typelist della classe derivata
-
13-12-2019 - |
Domanda
Utilizzo di CRTP (modello template ricorrente curiosamente) È possibile fornire una classe base con conoscenza delle classi ne derivate. Non è difficile creare un array che memorizza un'istanza di ogni classe che deriva da una classe base (vedi esempio)
class Base{
public:
static std::vector<Base *> m_derivedInstances;
};
template <class Derived>
class CRTPBase : public Base {
public:
static bool m_temp;
static bool addInstance()
{
m_derivedInstances.push_back(new Derived);
return true;
}
};
template <class Derived>
CRTPBase<Derived>::m_temp = CRTPBase<Derived>::addInstance();
.
Mi stavo chiedendo se fosse possibile creare un typelist (vedere http : //www.research.ibm.com/designpatterns/pubs/ph-jun00.pdf ) di tutti i tipi di classi derivate. Il problema è che ogni volta che il compilatore vede una nuova classe che deriva da Base
, dovrà aggiungere un nuovo tipo all'elenco, ma i typelist sono immutabili (è possibile creare una nuova lista con il nuovo tipo aggiunto ad esso, ma L'aggiunta di un elemento a un elenco è impossibile per quanto ne so. Alla fine vorrei avere qualcosa del genere:
struct DerivedClassHolder {
typedef Loki::TL::MakeTypeList</*list all derived classes here*/>::Result DerivedTypes;
};
.
L'obiettivo finale è quello di essere in grado di iterare su tutte le classi che derivano da Base
.
Soluzione
Può essere fatto, utilizzando una mappa di pseudo.Ecco alcuni esempi di codice usando Boost :: MPL.La definizione esplicita di "Implem" può essere eseguita con una macro in ogni intestazione di implementazione corrispondente.
#include <iostream>
#include <boost/mpl/vector.hpp>
#include <boost/mpl/eval_if.hpp>
#include <boost/mpl/identity.hpp>
#include <boost/mpl/for_each.hpp>
#include <boost/mpl/push_front.hpp>
#include <boost/mpl/empty_sequence.hpp>
#include <boost/type_traits/is_same.hpp>
using namespace boost::mpl;
using namespace boost;
// A type map. Implem #N of type Key is type (default: void)
template <typename Key, int N>
struct Implem
{
public:
typedef void type;
};
// Type vector building functions
// void, the default type, is used to stop the recursion
template <typename Key, int N = 1>
struct ImplemToList;
template <typename Key, typename Item, int N>
struct ImplemListItem
{
public:
typedef typename push_front<typename ImplemToList<Key, N + 1>::type, Item>::type type;
};
template <typename Key, int N>
struct ImplemToList
{
public:
typedef typename Implem<Key, N>::type item;
typedef typename eval_if<is_same<item, void>,
identity<vector<> >,
ImplemListItem<Key, item, N> >::type type;
};
// Example code: an interface with two implems
class Interface
{
public:
virtual const char* name() const = 0;
};
class Implem1 : public Interface
{
public:
virtual const char* name() const { return "implem_1"; }
};
class Implem2 : public Interface
{
public:
virtual const char* name() const { return "implem_2"; }
};
template <>
struct Implem<Interface, 1>
{
public:
typedef Implem1 type;
};
template <>
struct Implem<Interface, 2>
{
public:
typedef Implem2 type;
};
void print(Interface const& i)
{
std::cout << i.name() << std::endl;
}
int main()
{
typedef ImplemToList<Interface>::type IList;
for_each<IList>(&print);
}
. Altri suggerimenti
Il tuo typelist può essere creato solo a mano.Il problema che menzioni, l'immutabilità, è insormontabile.