一个专用模板类可以继承另一个专用模板类吗？

Question

I first defined

class Hash
{

};

Then a specialization of Hash.

template <class T>
class Hash<int, T>
{
public:
    Hash(int slotN = 11);

    bool insert(int key, T val);
    bool remove(int key);
    bool contains(int key);
    bool query(int key, T& val) ;

protected:
    // Basic Variables of the Hash Model.
    list<int>* slot;
    list<T>* slotVal;
    int slotN;
};

I want to use this specialized version of Hash to implement another specialization: Hash of String-Valued Keys.

template <class T>
class Hash<string, T> : public Hash<int, T>
{
public:
    Hash(int slotN);

    bool insert(string key, T val);
    bool remove(string key);
    bool contains(string key);
    bool query(string key, T& val) ;

private:

    // Calculate the String's Hash Key.
    int str2key( string key);
};

But it seemed I cannot access fields in the class Hash. Why?

Answer 1

When you say "I cannot access fields in the class Hash" I guess you mean, that you when you are using Hash<string, T> (for some type T ) that you cannot call the overloaded functions from Hash<int, T> . The reason for this is name hiding: when you overload a member function in a derived class, all members with the same name in the base class are hidden unless you make them explicitly available. The way to do it is a using declaration:

template <class T>
class Hash<string, T> : public Hash<int, T>
{
public:
    Hash(int slotN);

    using Hash<int, T>::insert;
    using Hash<int, T>::remove;
    using Hash<int, T>::contains;
    using Hash<int, T>::query;

    bool insert(string key, T val);
    bool remove(string key);
    bool contains(string key);
    bool query(string key, T& val) ;

private:

    // Calculate the String's Hash Key.
    int str2key( string key);
};

If you just need to access the base class members from your derived class's implementation, you can also access the names using qualification with the class name. For example:

template <typename T>
bool Hash<string, T>::insert(string key, T val) {
    return this->Hash<int, T>::insert(this->str2key(key, val);
}

Thinking a bit more about the question, there is another potential issue: If you access the data members in the base class you need to make sure that the compiler considers the name a dependent name. Otherwise it is looked up in phase one and won't the names in the base because the can only be found in phase two:

template <typename T>
bool Hash<string, T>::insert(string key, T val) {
    int n0 = slotN; // doesn't work: looked up in phase 1
    int n1 = this->slotN; // OK: name is dependent
    int n2 = Hash<int, T>::slotN; // OK, too
}

Personally, I wouldn't publicly derive from a class with a different key but I assume you have your reasons. BTW, I assume that your primary declaration of Hash looks something like this although it doesn't matter for the problem, really:

template <typename K, typename T>
class Hash;

(if it doesn't have any members, I would rather not define it, either).