Реализация класса хэширования для текста

class Hash {
private:
    int p, q;
    vector<vector<pair<int, int>>> hash_table;
public:
    Hash() = default;
    Hash(string text) {
        bool is_created_table;
        do {
            is_created_table = true;
            p = rand();
            q = ( 10078200 + rand() % 10000 ) % 100000000;
            hash_table.clear();
            hash_table.resize(q);
            for (int i = 0; i < text.size(); ++i) {
                int last = 0;
                for (int j = i; j < text.size(); ++j) {
                    int key = (last * p + text[j]) % q;
                    if (hash_table[key].size() > log2(q)) {
                        is_created_table = false;
                        break;
                    }
                    hash_table[key].push_back({ i, j });
                    last = key;
                }
            }
        } while (!is_created_table);
    }
 
    /*int getKey(string sub_str, string text) {
    }*/
};

#include <iostream>
#include <string>
#include <string_view>
 
int main()
{
    std::cout << std::hash<std::string>{}("meow") << '\n';
    std::cout << std::hash<std::string_view>{}("meow") << '\n';
}

#include <iostream>
#include <vector>
#include <string>
#include <fstream>
#include <ctime>
 
using namespace std;
 
class Hash {
private:
    int p, q;
    vector<vector<pair<int, int>>> hash_table;
public:
    Hash() = default;
    Hash(string text) {
        bool is_created_table;
        do {
            is_created_table = true;
            p = rand();
            q = ( 10078200 + rand() % 10000 ) % 100000000;
            hash_table.clear();
            hash_table.resize(q);
            for (int i = 0; i < text.size(); ++i) {
                int last = 0;
                for (int j = i; j < text.size(); ++j) {
                    int key = (last * p + text[j]) % q;
                    if (hash_table[key].size() > log2(q)) {
                        is_created_table = false;
                        break;
                    }
                    hash_table[key].push_back({ i, j });
                    last = key;
                }
            }
        } while (!is_created_table);
    }
 
    /*int getKey(string sub_str, string text) {
    }*/
};
 
int main() {
    srand(time(0));
    string str;
 
    ifstream in("text8");
    if (in.is_open()) {
        getline(in, str);
    }
    else {
        std::cout << "Error...";
        throw;
    }
    
    Hash h_str(str);
}

#include <iostream>
#include <cstdint>
#include <vector>
 
/**
 * @see http://isthe.com/chongo/tech/comp/fnv/#FNV-param
 */
template<typename Iterator>
uint64_t getFNV1a64(Iterator begin, Iterator end) {
    static const uint64_t FNV_PRIME = 1099511628211u;
    static const uint64_t OFFSET_BASIS = 14695981039346656037u;
 
    size_t result = OFFSET_BASIS;
    while (begin != end) {
        result ^= *begin++;
        result *= FNV_PRIME;
    }
 
    return result;
}
 
struct Hash {
    uint64_t operator()(const std::string &string) {
        return getFNV1a64(string.begin(), string.end());
    }
};
 
int main() {
    Hash hash;
 
    std::string text = "something for everybody";
    std::cout << hash(text);
 
    const size_t buckets = 64;
    std::vector<std::vector<std::pair<uint64_t, std::string>>> hashTable(buckets, std::vector<std::pair<uint64_t, std::string>>());
    auto hashKey = hash(text);
    hashTable[hashKey % buckets].push_back({hashKey, text});
 
    return 0;
}