在具有不同模板参数集的模板化 class 中使用模板化 object

Question

I'm trying to use a templated object in a templated class where the template parameters of the object are not the same ones needed by the class. It sounds a bit confusing because is not described correctly, here is an example.

The following class implements a binary search tree:

template <typename KEY, typename VALUE>
class BST{
  public:
    BST(void){
      cache = new GCACHE<uint64_t, BSTObject>(this);
    }

    struct{
     string value;
    }BSTObject;

    GCACHE<uint64_t, BSTObject>* cache;

    ...
}

the GCACHE class implements a generic cache, and to function correctly it needs a pointer to the BST it has to cache. This pointer is passed to the GCACHE constructor:

template <typename CKEY, typename OBJECT>
GCACHE{
  public:
   GCACHE( *** pointer to BST, a templated class whoose template types that are not CKEY and OBJECT ***); (A)
}

How can I specify/define in (A) a set of template parameters that is different to the one needed by GCACHE (CKEY and OBJECT in the example)? The template parameters of the GCACHE object are uint64_t and BSTObject and the template parameters of the BST object might be int and string .

I'm really confused. Maybe I'm getting it all wrong and the solution is very simple... thank you for your help.

I hope that the above example is clear enough to obtain help. If not please let me know so that I can rephrase the question.

Answer 1

What parts of BST does GCACHE need access to?

If it only needs to access parts that don't depend on the template parameters KEY and VALUE , then create an abstract interface class that BST implements, and use that class as the pointer type for the GCACHE constructor:

class BSTInterface {
    ...
};

template<typename KEY, typename VALUE>
class BST : public BSTInterface {
    ...
};

template <typename CKEY, typename OBJECT>
GCACHE{
  public:
   GCACHE(BSTInterface *bst); (A)
};

If GCACHE does need to access parts of BST that depend on template parameters, then you'll need to make GCACHE templated on those parameters as well:

template <typename CKEY, typename OBJECT, typename KEY, typename VALUE>
GCACHE{
  public:
   GCACHE(BST<KEY, VALUE> *bst); (A)
};

By the way, in general such a circular dependency between classes creates tight coupling and might indicate a design issue. Why would a "generic cache" need to know about the existence of a binary search tree? Or, if the cache is implemented as a tree, why would the tree implementation need to know about the existence of the cache?