Нахождение целых корней многочлена методом Горнера

//---------------------------------------------------------------------------
#include <iostream>
#include <conio.h>
#include <vcl.h>
#include <tchar.h>
#include <vcl.h>
#pragma hdrstop
 
//---------------------------------------------------------------------------
#pragma argsused
using namespace std;
char bufRus[256];
 
char *Rus(const char *text)
{
    CharToOem(text, bufRus);
    return bufRus;
}
 
int main(int argc, char *argv[])
{
    register unsigned int i;
    unsigned int n;
 
    cout << Rus("Введите количество элементов: ");
    cin >> n;                        //4
 
    if (n < 1) {
        cerr << Rus("Требуется хотя бы два элемента.") << endl;
        return EXIT_FAILURE;
    }
 
    double *a = new double[n];
    double *b = new double[n];
 
    cout << Rus("Введите делитель свободного члена: ");
    double c;
    cin >> c;                        // 2
 
    cout << Rus("Введите исходн. элем.:") << endl;
    for (i = 0; i < n; i++)
        cin >> a[i];
 
    cout << endl;                // 1 -1 -8 12
 
    /* Рисуем верхнюю рамку */
    for (i = 0; i < n; i++)
        cout << "+-------";
    cout << "+" << endl;
 
    /* Выводим исходные элементы */
    for (i = 0; i < n; i++)
        cout << "| " << a[i] << "t";
    cout << "|" << endl;
 
    /* Снова рамка */
    for (i = 0; i < n; i++)
        cout << "+-------";
    cout << "+" << endl;
 
    /* По условию, первый элемент b равен первому элементу a */
    b[0] = a[0];
    cout << "| " << *b << "t";
    for (i = 1; i < n; i++) {
        b[i] = b[i - 1] * c;
        /* В этом месте b[i] будет равно значению, записываемому во вторую строчку */
        b[i] += a[i];
        cout << "| " << b[i] << "t";
    }
    cout << "+" << endl;
 
    /* И ещё одна завершающая рамка */
    for (i = 0; i < n; i++)
        cout << "+-------";
    cout << "+" << endl << endl;
    if (b[n - 1] == 0)
        cout << Rus("Ответ: ") << c << endl;
    else
        cout << Rus("Ответ: нет");
    delete[]b;
    delete[]a;
    getch();
}
 
//---------------------------------------------------------------------------

#include <iostream>
#include <string>
#include <sstream>
#include <cstdlib>
#include <list>
 
typedef std::list<long> CoefList;
typedef CoefList RootList;
 
/* getRoots() возвращает список корней многочлена.
   В строке inputStr задаются коэффициенты многочлена - целые числа,
   разделенные пробельными символами */
RootList getRoots(const std::string& inputStr);
// а сюда передается список коэффициентов от самого страшего к младшему
RootList getRoots(const CoefList& coefList);
// возвращает остаток от деления многочлена с коэффициентами coefList на (x - x0)
long getRest(const CoefList& coefList, const long& x0);
 
int main()
{
   std::string coefStr;
   RootList rootList;
   int n = 0;
 
   std::cout << "введите коэфициенты при неизвестных: ";
   std::getline(std::cin, coefStr);
 
   rootList = getRoots(coefStr);
 
   if (rootList.empty())
   {
      std::cout << "Целых корней нет." << std::endl;
   }
 
   n = 0;
   for (RootList::const_iterator i = rootList.begin(); i != rootList.end(); ++i)
   {
      n++;
      std::cout << "x" << n << " = " << *i << std::endl;
   }
 
   return 0;
}
 
RootList getRoots(const std::string& inputStr)
{
   std::istringstream strStream(inputStr);
   CoefList coefList;
   long tmp;
 
   while (strStream >> tmp)
   {
      coefList.push_back(tmp);
   }
 
   // избавляемся от лидирующих нулей
   while (!coefList.empty() && coefList.front() == 0)
      coefList.pop_front();
 
   return getRoots(coefList);
}
 
RootList getRoots(const CoefList& coefList)
{
   RootList rootsList; // список корней
   long a0 = abs(coefList.back()); // модуль свободного члена
   const long MAX_A0_DIVISOR = a0 / 2; // максимальный делитель свободного члена
 
   if (coefList.empty())
      // если пустое уравнение
      return RootList();
 
   for (long a0_divisor = 1; a0_divisor <= MAX_A0_DIVISOR; ++a0_divisor)
   {
      if (a0 % a0_divisor != 0)
         // если не делится нацело, то это не корень
         continue;
 
      // проверка корней
      if (getRest(coefList, a0_divisor) == 0)
         rootsList.push_back(a0_divisor);
 
      if (getRest(coefList, -a0_divisor) == 0)
         rootsList.push_back(-a0_divisor);
   }
 
   // проверка на корень самого коэффициента свободного члена
 
   if (getRest(coefList, a0) == 0)
      rootsList.push_back(a0);
 
   if (getRest(coefList, -a0) == 0)
      rootsList.push_back(-a0);
 
   return rootsList;
}
 
long getRest(const CoefList& coefList, const long& x0)
{
   long rest = 0;
 
   for (CoefList::const_iterator i = coefList.begin(); i != coefList.end(); ++i)
   {
      rest = x0 * rest + (*i);
   }
 
   return rest;
}