Реализовать поле Галуа

// GF.h
 
#pragma once
 
typedef unsigned char uint8;
typedef unsigned int uint32;
 
class GF
{
public:    
    GF();
    GF(const uint32 polynomial);
 
    static void initializeTable(const uint32 generatorPolynomial, const uint8 generatorPolynomialDegree);
    static void deleteTable();
 
    GF operator+(const GF& rhs) const; // operator- is the same as operator+
    GF operator*(const GF& rhs) const;
    GF invert() const; // a/b == a * b.invert
 
 
private:
    uint32 m_polynomial;
 
    static uint32 m_generatorPolynomial;    
    static const uint32* m_polynomialTable;
    static const uint32* m_rootTable;
    static uint32 m_tableSize;
};

// GF.cpp
 
#include "GF.h"
 
const uint32* GF::m_polynomialTable = nullptr;
const uint32* GF::m_rootTable = nullptr;
uint32 GF::m_generatorPolynomial = 0;
uint32 GF::m_tableSize = 0;
 
GF::GF()
{
 
}
 
GF::GF(const uint32 polynomial)
{
    m_polynomial = polynomial;
}
 
void GF::initializeTable(const uint32 generatorPolynomial, const uint8 generatorPolynomialDegree)
{
    deleteTable();
 
    m_generatorPolynomial = generatorPolynomial;
 
    m_tableSize = (1 << generatorPolynomialDegree) - 1;
    uint32* table = new uint32[m_tableSize];
 
    // construct root table
    for(uint8 i = 0; i < generatorPolynomialDegree; ++i)
        table[i] = 1 << i;
 
    uint32 tableMask = (1 << generatorPolynomialDegree) - 1;
    for (uint32 i = generatorPolynomialDegree; i < m_tableSize; ++i)
    {
        table[i] = table[i - 1] << 1;
 
        if(table[i - 1] >> (generatorPolynomialDegree - 1))
        {
            table[i] ^= m_generatorPolynomial;
            table[i] &= tableMask;
        }
    }
 
    m_rootTable = table;
    
    // construct polynomial table
    table = new uint32[++m_tableSize];
    table[0] = 0;
    for(uint32 i = 0; i < m_tableSize - 1; ++i)
        table[m_rootTable[i]] = i;
 
    m_polynomialTable = table;
}
 
void GF::deleteTable()
{
    if((m_polynomialTable != nullptr) && (m_rootTable != nullptr))
    {
        delete[] m_polynomialTable;
        delete[] m_rootTable;
        m_polynomialTable = nullptr;
        m_rootTable = nullptr;
    }
}
 
GF GF::operator+(const GF& rhs) const
{
    return GF(m_polynomial ^ rhs.m_polynomial);
}
 
GF GF::operator*(const GF& rhs) const
{
    if(this->m_polynomial == 0)
        return *this;
    if(rhs.m_polynomial == 0)
        return rhs;
 
    return GF(m_rootTable[(m_polynomialTable[m_polynomial] + m_polynomialTable[rhs.m_polynomial]) % (m_tableSize - 1)]);
}
 
GF GF::invert() const
{
    if(m_polynomial == 0)
        throw "Division by zero";
 
    return GF(m_rootTable[m_tableSize - 1 - m_polynomialTable[m_polynomial]]);
}