Хэш - таблица методом цепочек

struct HashTable
{
     int key; 
     int value;
} hash[n];

for (i = 0; i < n; i++)
    {
        hash[i].key = ByDivisionHashFunction(A[i]);
        hash[i].value = A[i];
    }

struct pair
{
    int key,value;
};
struct my_list
{
//bla-bla-bla
    pair*find(int key)const;//Возвращает либо пару key:значение, либо фигу (0)
    pair*insert(int key,int value);//создает новую пару key:value, возвращает указатель на нее
};
struct hash_table
{
    pair*find(int key)const{return table[key/10].find(key);}
    my_list table[100500];
};

pair*find(int key)const{return table[key/10].find(key);}

pair*find(int key)const{return table[key/10].find(key);}

pair*insert(int key,int value);

my_list table[100500];

class Node 
{
        friend class HashTable;
        Node* next;
        int data;
    public:
        Node()
        {
        }
        Node(int d, Node* n)
        {
            data = d;
            next = n;
        }
        ~Node() 
        {
        }
};
class HashTable 
{
public:
    int size;
    vector<Node*>* Nodes;
    HashTable(int s)
    {
        size = s;
        Nodes = new vector<Node*>(size);
    }
    HashTable()
    {
        size = DEFAULT;
        Nodes = new vector<Node*>(size);
    }
    ~HashTable()
    {
    }
    void insert(int data)
    {
        int index = getHashByDivision(data);
        if (Nodes -> at(index) == NULL)
        {
            Nodes -> at(index) = new Node(data, NULL);
            return;
        }
        Node* p = Nodes -> at(getHashByDivision(data));
        while (p != NULL){
            if (p -> next == NULL)
            {
                p -> next = new Node(data, NULL);
                break;
            }
            p = p -> next;
        }
    }
    
    int getSize()
    {
        return size;
    }
    int getHashByDivision(int key)
    {
        return (key % getSize());
    }
    void print(int start)
    {
        int lineCount = 0;
        for (int i = start; i < Nodes -> size(); i++){
            cout << i << "\t";
            Node* p = Nodes -> at(i);
            while (p != NULL){
                cout << p -> data << " ";
                p = p -> next;
            }
            cout << endl;
        }
    }
};
int main(int argc, const char* argv[]){
    int n = 10;
    //argv[1] = "10";
    //argv[2] = "10";
    int A[] = { 40, 12, 79, 35, 43, 52, 83, 66, 89, 79 };
    
    
    HashTable* hash = new HashTable(n);
    for (int i = 0; i < n; i++){
        hash -> insert(A[i]);
    }
 
    hash -> print(0);
    
 
    system("pause");
    return 0;
}

int find(int data)
    {
        int index = getHashByDivision(data);
        if (Nodes -> at(index) == NULL)
        {
            return 0;
        }
        if (Nodes -> at(index) != NULL)
        {
            return 1;
        }
    }

for(Node*pos=Nodes -> at(getHashByDivision(data));pos;pos=pos->next)
    if(pos->data==data)
        return true;
return false;

Unhandled exception at 0x74D91AA0 in LR_5.0 (TA).exe: Microsoft C++ exception: std::out_of_range at memory location 0x00FEF720.

#include <iostream>
#include <stdlib.h>
#include <fstream>
#include "math.h"
#include <vector>
using namespace std;
int* ReadArrayFromFile(int* n, char* name)
{
    int i, s;
    ifstream File(name);
    if (!File)
    {
        cout << "Cannot find a file\n";
        exit(0);
    }
    File >> *n;
    File >> s;
    int *A = new int[*n];
    for (i = 0; i < *n; i++)
    {
        File >> A[i];
    }
    File.close();
    return A;
}
int* ReadSummsFromFile(int* s, char* name)
{
    int i, n;
    ifstream File(name);
    if (!File)
    {
        cout << "Cannot find a file\n";
        exit(0);
    }
    File >> n;
    File >> *s;
    int *A = new int[n];
    for (i = 0; i < n; i++)
    {
        File >> A[i];
    }
    int *S = new int[*s];
    for (i = 0; i < *s; i++)
    {
        File >> S[i];
    }
    File.close();
    free(A);
    return S;
}
 
using namespace std;
class Node 
{
        friend class HashTable;
        Node* next;
        int data;
    public:
        Node()
        {
        }
        Node(int d, Node* n)
        {
            data = d;
            next = n;
        }
        ~Node() 
        {
        }
};
class HashTable 
{
public:
    int size;
    vector<Node*>* Nodes;
    HashTable(int tableSize)
    {
        size = tableSize;
        Nodes = new vector<Node*>(size);
    }
    ~HashTable()
    {
    }
    void insertByMultiplication(int data)
    {
        int index = getHashByMultiplication(data);
        if (Nodes -> at(index) == NULL)
        {
            Nodes -> at(index) = new Node(data, NULL);
            return;
        }
        Node* p = Nodes -> at(getHashByMultiplication(data));
        while (p != NULL){
            if (p -> next == NULL)
            {
                p -> next = new Node(data, NULL);
                break;
            }
            p = p -> next;
        }
    }
    void insertByDivision(int data)
    {
        int index = getHashByDivision(data);
        if (Nodes -> at(index) == NULL)
        {
            Nodes->at(index) = new Node(data, NULL);
            return;
        }
        Node* p = Nodes -> at(getHashByDivision(data));;
        while (p != NULL){
            if (p -> next == NULL)
            {
                p -> next = new Node(data, NULL);
                break;
            }
            p = p -> next;
        }
    }
    int searchKeyByDivision(int data)
    {
        for (Node* pos = Nodes -> at(getHashByDivision(data)); pos; pos = pos -> next)
        {
            if (pos -> data == data)
                return 1;
        }
        return 0;
    }
    int searchKeyByMultiplication(int data)
    {
        for (Node* pos = Nodes -> at(getHashByMultiplication(data)); pos; pos = pos -> next)
        {
            if (pos -> data == data)
                return 1;
        }
        return 0;
    }
    int getSize()
    {
        return size;
    }
    int getHashByDivision(int key)
    {
        return abs(key % getSize());
    }
    int getHashByMultiplication(int key)
    {
        float A = 0.618033;
        int hashCode = getSize() * fmod (key * A, 1);
        return hashCode;
    }
    void print(int start)
    {
        int lineCount = 0;
        for (int i = start; i < (Nodes -> size()); i++){
            cout << i << "\t";
            Node* p = Nodes -> at(i);
            while (p != NULL){
                cout << p -> data << " ";
                p = p -> next;
            }
            cout << endl;
        }
    }
};
 
int main(int argc, char* argv[])
{
    int n, s, i, j, k, y, counter, choose = 1;
 
    argv[1] = "input_10.txt";
 
    int* A = ReadArrayFromFile(&n, argv[1]);
    int* S = ReadSummsFromFile(&s, argv[1]);
 
    for (i = 0; i < n; i++)
    {
        for (j = i + 1; j < n; j++)
        {
            if (A[i] == A[j])
            {
                for (k = j; k < n; k++)
                {
                    A[j] = A[j + 1];
                }
                n--;
            }
        }
    }
 
    HashTable* hash = new HashTable(n * 2 + 1);
 
    switch (choose)
    {
        case 1:
        {
                  for (int i = 0; i < n; i++)
                  {
                      hash -> insertByMultiplication(A[i]);
                  }
                  hash->print(0);
                  system("pause");
                  for (i = 0; i < s; i++)
                  {
                      counter = 0;
                      for (j = 0; j < n; j++)
                      {
                          y = S[i] - A[j];
                          if (hash -> searchKeyByMultiplication(y) == 1)
                          {
                              cout << endl << A[j] << " " << y;
                              counter++;
                              break;
                          }
                      }
                      if (counter == 0)
                          cout << endl << 0 << " " << 0;
                  }
                  cout << endl;
        }
        case 2:
        {
                  for (int i = 0; i < n; i++)
                  {
                      hash -> insertByDivision(A[i]);
                  }
                  hash -> print(0);
                  system("pause");
                  for (i = 0; i < s; i++)
                  {
                      counter = 0;
                      for (j = 0; j < n; j++)
                      {
                          y = S[i] - A[j];
                          if (hash -> searchKeyByDivision(y) == 1)
                          {
                              cout << endl << A[j] << " " << y;
                              counter++;
                              break;
                          }
                      }
                      if (counter == 0)
                          cout << endl << 0 << " " << 0;
                  }
                  cout << endl;
        }
    }
 
    system("pause");
    return 0;
}