C ++-模板子类继承自多个模板类

Question

I am creating a simple class named HashMap :

template <typename K,typename V> class HashMap{
    .
    .
    .
    public:

        class Hashable;

I created another class:

template<typename T> class Stack;

Now I must create a new class ( NewStackClass ), which extends Stack and HashMap<K,V>::Hashable .

Objects of this class are meant to be instantiated when K=Stack/NewStackClass.

Example:

HashMap<NewStackClass<int>,int> map;
//T=int;K=NewStackClass<int>;V=int;

or:

HashMap<Stack<char>,int> map;
//T=char;K=Stack<char>;V=int;

How can I obtain this? Also, I want to split class declaration from its implementation.

I already tried with this:

template <typename B, typename C>
template <typename A> class NewStackClass : public Stack<A>, public HashMap<B,C>::Hashable{

    virtual int hashCode() const;
    bool operator==(const MyStack<A>& stack);
};

but it didn't work:

[Error] too many template-parameter-lists

Any help is appreciated.

EDIT

Creating NewStackclass:

    template <typename StackType,typename HashMapValue> class MyStack : public NewStackClass<StackType>, public HashMap<Stack<StackType>,HashMapValue>::Hashable{

        virtual int hashCode() const {

            return 1;
        }

        bool operator==(const NewStackClass<StackType,HashMapValue>& stack){

            return true;
        }
    };

Let's get in the private area of HashMap class:

private:

    int hash(const Hashable& key) const{

        return (31*17 +key.hashCode()) % TABLE_SIZE;
    }

Doing this in main.cpp:

HashMap<NewStackClass<int,int>,int> map1;

NewStackClass<int,int> stack;
map1.put(stack,0);

Brings out this error:

[Error] no matching function for call to "HashMap<NewStackClass<int, int>, int>::hash(const NewStackClass<int, int>&)"

Error comes from this:

[Note] no known conversion for argument 1 from 'const NewStackClass' to 'const HashMap, int>::Hashable&'

Answer 1

Your code contains a syntactical flaw. You may only have a single template parameter list for your class.

merge

template <typename B, typename C>
template <typename A> class NewStackClass ...

to this

template <typename B, typename C, typename A>
class NewStackClass ...

to make it compile. Also you did not provide information on what MyStack is supposed to be. I just assume that you meant to write Stack instead.

You should also think about whether your class NewStackClass really needs three template arguments or if there are actually only two distinct ones.

Judging by your question, your might want to do:

template <typename K, typename V>
class NewStackClass : public Stack<K>, public HashMap<Stack<K>,V>::Hashable {

instead.

Fixed Code (Syntax Only)

template <typename K,typename V>
class HashMap {
public:
    class Hashable {
    };
};

template<typename T> class Stack {
};

template <typename B, typename C, typename A>
class NewStackClass : public Stack<A>, public HashMap<B,C>::Hashable {

    virtual int hashCode() const;
    bool operator==(const Stack<A>& stack);
};