Нужны комментарии к коду хеш-таблицы

 //мэйн
#include "stdafx.h"
#include "Hash_Twin_Chain.h"
#include <iostream>
#include <ctime>
 
struct AAA
{
    int key;
    char *mas;
    AAA(int k,char*z)
    {
        key=k;
        mas=z;
}
};
int hf(void* d)
{
    AAA* f = (AAA*)d;
    return f->key;
}
 
void AAA_print(void*d)//доп                     генерир опред кол хэш табл, время
{
    std::cout<<"     key      "<<((AAA*)d)->key
        <<"  -  "<<((AAA*)d)->mas<<std::endl;
}
 
char*str1="abcdefghijklmnopqrstuvwxyz1234567890";//доп
char*str2="";
char a;
 
int _tmain(int argc, _TCHAR* argv[])
{
    const int current_size=2;
    AAA a1 (1,"one"),
        a2 (1,"two"),
        a3 (1,"three"),
        a4 (4,"four");
    hashTC::Object H=hashTC::Create(current_size,hf);
 
    for(int i=0;i<256;i++)      
        H.rand8[i]=rand()%current_size;
 
    bool rc03=H.Insert(&a1);
         rc03=H.Insert(&a2);
         rc03=H.Insert(&a3);
         rc03=H.Delete(&a4);
        rc03=H.Insert(&a4);
        rc03=H.Insert(&a4);
        rc03=H.Insert(&a4);
        rc03=H.Insert(&a4);
    H.Scan();
    listx::Element* eee=H.Search(&a1);
 
 
    clock_t t1=0, t2=0;//доп
    for(int NNN=16; NNN<=128; NNN*=2)
    {
        AAA aa (8 , "ui");
        hashTC::Object H1=hashTC::Create(NNN,hf);
        for(int i = 0;i<NNN; i++)
        {
            srand(time (0));//чтобы случ числа были разными
            int k=rand()%NNN;//генер случ число
            aa.key=k;//запис ее в ключ структ ААА
                srand(time (0));
                for(int i =0;i<5;i++)
                {
                    a=str1[(rand()%strlen(str1))+1];
                aa.mas=&a;//накапливаем
                }
        
        H1.Insert(&aa);
        }
    
        t1=clock();
        AAA_print(H1.Search(&aa));
        t2= clock();
        std::cout<<"time:"<<(double)(t2-t1)/
            (double)CLOCKS_PER_SEC<<std::endl;
    }
    return 0;
}
 
#pragma once //Hash_Twin_Chain.h
#include "Lists.h"
namespace hashTC
{
    struct Object//объект таблицы
    {
        int Size;
        int (*FunKey)(void*);
        listx::Object* Hash;
        Object(int size,int (*f)(void*))//конструктор
        {
            Size=size;
            FunKey=f;
            Hash=new listx::Object[Size];//массив из size  объектов списка
        };
        int HashFunction(void* data);
        bool Insert(void* data);
        listx::Element* Search(void* data);
    bool Delete(int key);
        bool Delete(void* data);
        void Scan();//просмотр таблицы
        unsigned char rand8[256];//таблица беззнаковых чаров,для вычисления универсального хэша называется ранд 8  размером 
    };
    Object Create(int size,int (*f)(void*));
}
 
#include "stdafx.h" //Hash_Twin_Chain.срр
#include "Hash_Twin_Chain.h"
#include "Lists.h"
#include<iostream>
 
struct AAA//структура
{
    int key;
    char *mas;
    AAA(int k,char*z)
    {
        key=k;
        mas=z;
    }
};
namespace hashTC
{
    Object Create(int size,int (*f)(void*)) {return *(new Object(size,f));}
    //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    //int Object::HashFunction(void* data){return (FunKey(data)%Size);};
    //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    bool Object::Insert(void* data){return (Hash[HashFunction(data)].Insert(data));};//по данным вычисл хэш функц котор опред номер списка, вставл в список
    //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    bool Object::Delete(void* data){return (Hash[HashFunction(data)].Delete(data));};
    //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    listx::Element* Object::Search(void* data){return Hash[HashFunction(data)].Search(data);};
    //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    int Object::HashFunction(void* data)
    {
        int h, a=31415, b=27183; 
        char*str=(((AAA*)data)->mas);
        for(h=0; *str!=0; str++,a=a*b%(Size-1))
        h=(a*b+*str)%Size;
        return(h<0)?(h=Size):h;
    
    }
    void Object::Scan()
    {
        for(int i=0;i<Size;i++)
        {
            Hash[i].Scan(); std::cout<<'\n';        
        }
    };
}
#include "stdafx.h"  // Lists.срр
#include "Lists.h"
#include<iostream>
 struct AAA//элемент таблицы
 {
     int key;
     char *mas;
 };
namespace listx
{
    Permit Object::Perm=ALL;
    //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    bool Object::Insert(void* data)
    {
        bool rc;
        if(rc=!isLockInsert())
        {
            if(Head==NIL) Head=new Element(NIL,data,NIL);
            else this->GetLast()->Next=new Element(this->GetLast(),data,NIL);
        }
        return rc;
    }
        //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    Element* Object::Search(void* data)//поиск элементов
    {
        Element* rc=Head;
        while((rc!=NIL)&&(rc->Data!=data)) rc=rc->Next;
        return rc;
    }
    //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    bool Object::Delete(Element* e)//удаление
    {
        bool rc;
        if(rc=!isLockDelete())
        {
            if(rc=(e!=NIL))
            {
                if(e->Next!=NIL) e->Next->Prev=e->Prev;
                if(e->Prev!=NIL) e->Prev->Next=e->Next;
                else Head=e->Next;
                delete e;
            }
        }
        return rc;
    }
    //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    bool Object::Delete(void* data)//удаление по значению
    {
        return Delete(Search(data));
    }
    //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    Element* Object::GetLast()
    {
        listx::Element* e=this->GetFirst(),*rc=this->GetFirst();
        while(e!=listx::NIL)
        {
            rc=e;
            e=e->GetNext();
        };
        return rc;
    }
    //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    void AppendList(Object& to, const Object& from)
    {
        to.GetLast()->Next=from.Head->Next;
    }
    //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    void CopyList(Object& to, const Object& from)
    {
        to.Head->Next=from.Head->Next;
    }
    //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    Object Create() {return *(new Object());};
 
 
void Object::Scan()
{
    listx::Element*e=this->GetFirst();
    while(e!=listx::NIL)
    {
        std::cout<<((AAA*)e->Data)->key<<
            '-'<<((AAA*)e->Data)->mas<<'/';
        e=e->GetNext();
    };
 
}
}
 
#pragma once   //Lists.h
#define LISTNIL (Element*)-1
namespace listx
{
    struct Element
    {
        Element* Prev;
        Element* Next;
        void* Data;
        Element(Element* prev,void* data,Element* next)// конструктор
        {
            Prev=prev;
            Data=data;
            Next=next;
        }
        Element* GetNext(){return Next;};
        Element* GetPrev(){return Prev;};
    };
    static Element* NIL=LISTNIL;
    enum Permit{ALL=0,NOINSERT=1,NODELETE=2,NOUPDATE=3};
    struct Object
    {
        Element* Head;
        Object(){Head=NIL;};
        Element* GetFirst(){return Head;};
        Element* GetLast();//получить указатель на посл
        Element* Search(void* data);
        bool Insert(void* data);
        bool Delete(Element* e);
        bool Delete(void* data);
        static Permit Perm;
        bool isLockInsert(){return (Perm==NOINSERT||Perm==NOUPDATE);};
        bool isLockDelete(){return (Perm==NODELETE||Perm==NOUPDATE);};
        bool isListEmpty(){return (Head==NIL);};
        void Scan();//просмотр или сканирование списка
    };
    Object Create();
    void AppendList(Object& to, const Object& from);
    void CopyList(Object& to, const Object& from);
}
#undef LISTNIL