Classe modèle qui prend une Classe modèle qui prend une Classe concrète

Question

Bien que j'aie vu quelques messages concernant la prise en compte des classes de modèles comme paramètre dans une classe de modèle, je n'arrive pas à trouver quelque chose qui fonctionne avec mon code, ou simplement je ne comprends pas assez bien l'explication.

En fin de compte, je cherche une classe modèle qui prend une autre classe modèle qui prend une classe standard.

*Note : Par souci de brièveté, je n'ai inclus que les informations que je juge suffisantes.

J'ai fait une tentative sur la base des informations que j'ai pu trouver et elle est présentée ici :

Classe de béton

class ConcreteClass {
   private:
      std::string words;
   public:
      ConcreteClass(std::string newWords);
};
#endif

Modèle de classe Modèle de classe

template <class ConcreteClass>
class TemplateClass{
   private:
     ConcreteClass stuff;
   public:
     TemplateClass(ConcreteClass fillStuff);
};

#endif

template <class ConcreteClass>
TemplateClass<ConcreteClass>::TemplateClass(ConcreteClass fillStuff) {
     stuff = fillStuff;
}

Modèle de classe de base

template<template<class> ConcreteClass, class TemplateClass>
class BaseClass {
   private:
     TemplateClass<ConcreteClass>* objPntr;
}

template<template<class> ConcreteClass, class TemplateClass>
BaseClass<TemplateClass<ConcreteClass>::BaseClass(TemplateClass<ConcreteClass>* newObj) {
    objPntr = newObj;
}
template<template<class> ConcreteClass, class TemplateClass>
BaseClass<TemplateClass<ConcreteClass>::~BaseClass() {
   if(objPntr) {
      delete objPntr;
    }
}

Principal

int main() {
   ConcreteClass cClass("some values");
   TemplateClass tClass(cClass);
   BaseClass(tClass);

   return 0;
}

Answer 1

Tout d'abord, vous avez besoin d'un class o typename avant le nom du paramètre du modèle dans le cas des modèles. Deuxièmement, vous devez mettre le mot-clé template<class> antes de TemplateClass pas ConcreteClass . TemplateClass es votre type de modèle, il a donc besoin de ce spécificateur :

#include <string>

// I had to make up your types because there is no definition for them
struct ConcreteClass {
    std::string value;
};

template <typename T>
struct TemplateClass {
    T t;
};

template<class ConcreteClass, template<class> class TemplateClass>
class BaseClass {
   private:
     TemplateClass<ConcreteClass>* objPntr;

// constructor needs to be declared before being defined
public:
     BaseClass(TemplateClass<ConcreteClass> *objPntr);
};

template<class ConcreteClass, template<class> class TemplateClass>
BaseClass<ConcreteClass, TemplateClass>::BaseClass(TemplateClass<ConcreteClass>* newObj) {
    objPntr = newObj;
}

int main() {
   ConcreteClass cClass{"some values"};
   TemplateClass<ConcreteClass> tClass{cClass};
   BaseClass<ConcreteClass, TemplateClass> bClass(&tClass);
}