Многочлены над GF(2^m)

#ifndef RS_encoder.h
 
#include <vector>
 
const int GROUP_DEGREE = 0; // = m -- порядок группы GF(2^m)
const std::vector<int> PRIMITIVE_POLYNOMIAL (0); // примитивный полином в GF(2^m)
 
class GF 
{
private:
    int alpha_power; // представление в виде степени альфа
    std::vector<int> alpha_vector; // представление в виде вектора
    bool null; // индикатор того, что вектор нулевой
 
    void power_to_vector ();
    void vector_to_power ();
 
public:
    GF ();
    GF (int power); // используем power_to_vector
    GF (std::vector<int> vector); // используем vector_to_power
    ~GF ();
 
    GF operator+ (GF right_hand_side); // сложение
    GF operator* (GF right_hand_side); // умножение
 
    void show_alpha_vector (); //вывод на экран вектора
};
 
#endif

#ifndef GF_polynom.h
 
#include "GF.h"
 
class GF_polynom
{
private:
    std::vector<GF> polynom; // вектор из коэфициентов полинома,
                             // которые принадлежат GF(2^m)
public:
    GF_polynom ();
    GF_polynom (std::vector<GF> coefficients);
    ~GF_polynom ();
 
    GF_polynom operator+ (GF_polynom right_hand_side); // сложение 
    GF_polynom operator* (GF_polynom right_hand_side); // умножение
    GF_polynom operator% (GF_polynom right_hand_side); // остаток от деления
};
 
#endif

#ifndef RS_encoder.h
 
#include "GF_polynom.h"
#include <string>
 
const int CODE_LENGTH = 0; // длина кода
const int MESSAGE_LENGTH = 0; // длина сообщения
 
std::vector<int> str_to_int (std::string str_message); // строку в вектор
std::vector<GF> message_to_GF_message (std::vector<int> message); // вектор из 0 и 1 в 
                                                                  // вектор из элементов GF(2^m)
std::vector<GF> encode (std::vector<GF> GF_message, int n = CODE_LENGTH, int k = MESSAGE_LENGTH); // кодирование сообщения
 
#endif

/* * * * * * * * * * * * * * * * * * * * * * *
                main.cpp
* * * * * * * * * * * * * * * * * * * * * * */
 
#include <iostream>
#include "RS_encoder.h"
 
int main()
{
    std::string str_mess1, str_mess2;
 
    std::cout << "IT'S POLYNOM TEST" << std::endl << std::endl;
    std::cout << "Group degree = " << GROUP_DEGREE << std::endl;
    std::cout << "Maximum message length = " << MESSAGE_LENGTH * GROUP_DEGREE << " bits" << std::endl;
    std::cout << "Maximum number of errors = " << MAX_ERRORS << " symbols" << std::endl;
    std::cout << "--------------------------------------------" << std::endl;
 
    std::cout << "input 1st message: ";
    std::cin >> str_mess1;
    GF_polynom polynom1 (message_to_GF_message (str_to_int (str_mess1)));
 
    std::cout << std::endl << "input 2nd message: ";
    std::cin >> str_mess2;
    GF_polynom polynom2 (message_to_GF_message (str_to_int (str_mess2)));
 
    std::cout << std::endl << "------------------------------------------" << std::endl;
 
    std::vector<GF> temp_GF_vec (polynom1.return_coefficients());
    
    std::cout << "1st messege, transformed to polynom:" << std::endl;
    std::cout << "degree\tvector\tpower" << std::endl;
    int temp_degree = 0;
    for (auto gf_vec_iter = temp_GF_vec.begin(); gf_vec_iter != temp_GF_vec.end(); ++ gf_vec_iter)
    {
        std::cout << temp_degree << "\t";
        std::vector<int> temp_vec (gf_vec_iter->return_alpha_vector());
        for (auto iter = temp_vec.begin(); iter != temp_vec.end(); ++iter)
            std::cout << *iter;
        std::cout << "\t" << gf_vec_iter->return_power() << std::endl;
        ++temp_degree;
    }
 
    
    temp_GF_vec = polynom2.return_coefficients();
    
    std::cout << "2nd messege, transformed to polynom:" << std::endl;
    std::cout << "degree\tvector\tpower" << std::endl;
    temp_degree = 0;
    for (auto gf_vec_iter = temp_GF_vec.begin(); gf_vec_iter != temp_GF_vec.end(); ++ gf_vec_iter)
    {
        std::cout << temp_degree << "\t";
        std::vector<int> temp_vec (gf_vec_iter->return_alpha_vector());
        for (auto iter = temp_vec.begin(); iter != temp_vec.end(); ++iter)
            std::cout << *iter;
        std::cout << "\t" << gf_vec_iter->return_power() << std::endl;
        ++temp_degree;
    }
 
    GF_polynom polynom3 = polynom1 * polynom2;
 
    temp_GF_vec = polynom3.return_coefficients();
    
    std::cout << "Product of polynom1 and polynom2:" << std::endl;
    std::cout << "degree\tvector\tpower" << std::endl;
    temp_degree = 0;
    for (auto gf_vec_iter = temp_GF_vec.begin(); gf_vec_iter != temp_GF_vec.end(); ++ gf_vec_iter)
    {
        std::cout << temp_degree << "\t";
        std::vector<int> temp_vec (gf_vec_iter->return_alpha_vector());
        for (auto iter = temp_vec.begin(); iter != temp_vec.end(); ++iter)
            std::cout << *iter;
        std::cout << "\t" << gf_vec_iter->return_power() << std::endl;
        ++temp_degree;
    }
 
    std::cin.get();
    std::cin.get();
}

GF_polynom GF_polynom::operator* (const GF_polynom& right_hand_side) const
{   
    GF_polynom left_multiplier (*this);
    GF_polynom right_multiplier (right_hand_side);
 
    while (left_multiplier.polynom.rbegin()->return_alpha_vector() == null_vector)
        left_multiplier.polynom.pop_back();
 
    while (right_multiplier.polynom.rbegin()->return_alpha_vector() == null_vector)
        right_multiplier.polynom.pop_back();
 
    GF_polynom prod;
    prod.polynom.reserve (left_multiplier.polynom.size() + right_multiplier.polynom.size() - 1);
 
    for (int k = 0; k < left_multiplier.polynom.size() + right_multiplier.polynom.size() - 1; ++k)
    {
        GF sum (null_vector);
 
        for (int i = std::max (0, k - (int) right_multiplier.polynom.size() + 1); 
                            i <= std::min (k, (int) left_multiplier.polynom.size() - 1); ++i)
            sum = sum + (left_multiplier.polynom.at(i) * right_multiplier.polynom.at(k - i));
 
        prod.polynom.push_back (sum);
    }
 
    return prod;
}

#include <algorithm>
#include <array>
#include <iostream>
#include <vector>
 
template <typename TContent>
void erase_start_nulls(std::vector<TContent>& i_vector, const TContent& null_element)
{
   auto it = std::find_if(i_vector.begin(), i_vector.end(), [&](const TContent& i){ return i!=null_element; });
   i_vector.erase(i_vector.begin(), it);
}
 
int main()
{
   std::array<int, 5> arr = {{0, 0, 0, 42, 7}};
   std::vector<int> data(arr.cbegin(), arr.cend());
   
   erase_start_nulls(data, 0);
      
   for (int i : data)
      std::cout << i << " ";
   return 0;
}

#include <algorithm>
#include <array>
#include <iostream>
#include <vector>
 
template <typename TContent>
void erase_end_nulls(std::vector<TContent>& i_vector, const TContent& null_element)
{
   auto rit = std::find_if(i_vector.rbegin(), i_vector.rend(), [&](const TContent& i){ return i!=null_element; });
   if (rit != i_vector.rend())
   {
      i_vector.erase(rit.base(), i_vector.end());
   }
}
 
int main()
{
   std::array<int, 5> arr = {{42, 7, 0, 0, 0}};
   std::vector<int> data(arr.cbegin(), arr.cend());
   
   erase_end_nulls(data, 0);
      
   for (int i : data)
      std::cout << i << " ";
   return 0;
}