hashTab

//класс списка
template <typename T>
class list
{
    struct Node {
        std::string key;
        T value;
        Node *next;
    };
    Node *head, *tail;
    size_t len;
public:
    list()
    {
        head = tail = nullptr;
        len = 0;
    }
    ~list()
    {
        Node* e(head);
        while (e) {
            Node* buf(e->next);
            delete e;
            e = buf;
        }
    }
    //добавит в список узел
    void push(const std::string& k, T val)
    {
        len++;
        Node* e(new Node);
        e->key = k; e->value = val;
        e->next = nullptr;
        if (head) {
            tail->next = e;
            tail = e;
        }
        else head = tail = e;
    }
    //вернет значение по ключу
    T& take(const std::string& k)
    {
        Node* e(head);
        while (e->key != k) {
            e = e->next;
        }
        return e->value;
    }
    void print()
    {
        Node* e(head);
        if (!e) std::cout << " { empty } " << std::endl;
        else {
            std::cout << " { ";
            while (e) {
                std::cout << " Key: " << e->key << " Value: " << e->value << " ";
                e = e->next;
            }
            std::cout << "}";
        }
    }
    size_t size()
    {
        return len;
    }
};
//класс словаря основанного хэш-таблице
template <typename T>
class htD
{
    size_t hMul; //кол-во символов
    size_t tSize; //размер таблицы
    list<T>* table;//таблица
public:
    htD(size_t s)
    {
        hMul = 31;
        tSize = s;
        table = new list<T>[tSize];
    }
    ~htD()
    {
        delete[] table;
    }
    //хэш-функция
    int hashKP(const std::string& k)
    {
        size_t h (0);
        for (size_t i(0); i < k.length(); i++)
            h = h * hMul + (size_t)k[i];
        return h % tSize;
    }
    //хэш-функция дженскинса
    uint32_t hashJ(const std::string& k)
    {
        uint32_t hash = 0;
        for (size_t i (0); i < k.length(); i++) {
            hash += k[i];
            hash += (hash << 10);
            hash ^= (hash >> 6);
        }
        hash += (hash << 3);
        hash ^= (hash >> 11);
        hash += (hash << 15);
        return hash % tSize;
    }
    //добавит значение в таблицу спомощью хэ-функции дженкинса
    void pushJ(const std::string& k, T val)
    {
        table[hashJ(k)].push(k, val);
    }
    //добавит значение
    void pushKP(const std::string& k, T val)
    {
        table[hashKP(k)].push(k, val);
    }
    //количество коллизий
    size_t collisionNum()
    {
        size_t count(0);
        for (size_t i(0); i < tSize; i++) {
            size_t s = table[i].size();
            count += (s > 1 ? s : 0);
        }

        return count;
    }
    //вернет значение по ключу
    T& takeKP(const std::string& k)
    {
        return table[hashKP(k)].take(k);
    }
    //вернет значение по ключу с помощью функции дженкинса
    T& takeJ(const std::string& k)
    {
        return table[hashJ(k)].take(k);
    }