Template Class that takes a Template Class that Takes a Concrete Class

Question

While I've seen a few posts regarding taking in template classes as a parameter into a template class I can't seem to find something that works with my code, or simply I do not understand the explanation well enough.

Ultimately, I'm looking for a template class that takes another template class which takes a standard class.

*Note: For brevity, I've only included what I believe to be sufficient information.

I've made an attempt based on the information I could find and it is shown here:

Concrete Class

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

Template Class template

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

#endif


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

Base Class template


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

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

Main

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

   return 0;
}

user_5740428 · Answer

Firstly, you need a class or typename keyword before the template parameter name in the case of template-templates. Secondly, you should put the template before TemplateClass, not ConcreteClass. TemplateClass is your templated type, so it needs that specifier:

#include 

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

template 
struct TemplateClass {
    T t;
};

template class TemplateClass>
class BaseClass {
   private:
     TemplateClass* objPntr;

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

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

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

Template Class that takes a Template Class that Takes a Concrete Class

1 Answers