抽象基类具有抽象的嵌套类

我的代码结构如下。我有一个基本的抽象类，它还具有嵌套的抽象迭代器。我从基类继承，也从抽象基础继承类继承。为了分配我使用多态性的对象：

我遇到的错误：

    In file included from newDataStore.h:6:0,
                     from newDataStore.cpp:1:
    ../HashTable/baseHashTable.h: In instantiation of ‘class BaseHashTable<std::basic_string<char>, User*>::iterator’:
    ../HashTable/hashTable.h:53:8:   required from ‘class HashTable<std::basic_string<char>, User*>::iterator’
    ../HashTable/hashTable.h:8:7:   required from ‘class HashTable<std::basic_string<char>, User*>’
    newDataStore.cpp:10:25:   required from here
    ../HashTable/baseHashTable.h:59:19: error: cannot allocate an object of abstract type ‘BaseHashTable<std::basic_string<char>, User*>::iterator’
      virtual iterator begin() const = 0;
                       ^
    ../HashTable/baseHashTable.h:27:8: note:   because the following virtual functions are pure within ‘BaseHashTable<std::basic_string<char>, User*>::iterator’:
      class iterator

我的代码结构合适吗？如何摆脱编译器错误：不能分配抽象类的对象？

Code:
// Instantiating the hash table
myUserHashTable = new HashTable<string, User*>; 
        template<class KeyType, class ValueType>
        class BaseHashTable // abstract class
        {
            class iterator
        {
        public:
            virtual const ValueType& operator*() const = 0;
            virtual iterator operator++() = 0;
            bool operator==(const iterator& other) const
            {
                return (row == other.row && parent_ == other._parent);
            }
            bool operator!=(const iterator& other) const
            {
                return !(*this == other);
            }
            friend class BaseHashTable;
            virtual BaseHashTable<KeyType,ValueType>* getParent() const = 0;
            protected:
                iterator(int row, const BaseHashTable* parent)
                {
                    this->row = row;
                    parent_ = parent;
                }
                int row;
                const BaseHashTable* parent_;
        };
        virtual iterator begin() const = 0;
        virtual iterator end() const = 0;
protected:
int _size;
        };
        template<class KeyType, class ValueType>
        class HashTable : public BaseHashTable<KeyType, ValueType>
        {
            class iterator: public BaseHashTable<KeyType, ValueType>::iterator
        {
        public:
            const ValueType& operator*() const
            {
                return getParent()->hashTB[this->row]->at(col).second;
            }
            iterator operator++()
            {
                if (getParent()->hashTB[this->row]->size() > col+1)
                {
                    col += 1;
                    return *this;
                } else {
                    for (int i = this->row+1; i < this->parent_->_size; ++i)
                    {
                        if(getParent()->hashTB[i]->size() > 0)
                        {
                            this->row = i;
                            col = 0;
                            return *this;
                        }
                    }
                    this->row = getParent()->_size;
                    col = 0;
                    return *this;
                }
            }
            bool operator==(const iterator& other) const
            {
                return (this->col == other.col) ? BaseHashTable<KeyType, ValueType>::iterator::operator==(other) : false;
            }
            bool operator!=(const iterator& other) const
            {
                return !(*this == other);
            }
            HashTable<KeyType,ValueType>* getParent() const
            {
                return ((HashTable<KeyType, ValueType>*)this->parent_);
            }
            friend class HashTable<KeyType, ValueType>;
            private:
                iterator(int row, int col, const BaseHashTable<KeyType, ValueType>* parent): BaseHashTable<KeyType, ValueType>::iterator(row, parent)
                {
                    this->col = col;
                }
                int col;
        };
        iterator begin() const
        {
            typename std::vector<std::pair<KeyType, ValueType> >::iterator it;
            int j = 0;
            for (int i = 0; i < this->_size; ++i)
            {
                if(hashTB[i]->size() > 0)
                    return iterator(j,0, this);
                j++;
            }
        }
        iterator end() const {
            return iterator(this->_size, 0, this);
        }
    protected:
    std::vector<std::pair<KeyType, ValueType> >** hashTB;
        };
        template<class KeyType, class ValueType>
        class DoubleHashingHashTable : public BaseHashTable<KeyType, ValueType>
        {
           class iterator {/*Implementation*/ } : public BaseHashTable<KeyType, ValueType>::iterator
           iterator begin() const {/*Implementation*/}
           iterator end() const {/*Implementation*/}
        };