Пояснительная записка
«Реализация класса больших чисел»
Введение
Постановка задачи
Реализовать средствами языка С++ класс больших целых чисел. Для написания класса были выделены следующие задачи:
· Организовать чтение из консоли и печать в консоль целых чисел, длина которых превышает 232
разрядов (стандартный тип long)
· Реализовать выполнение арифметических операции с данными числами:
o Сложение
o Вычитание
o Произведение
o Нахождение целой части от деления
o Нахождение остатка от деления
o Возведение в степень
Факториал
Ход решения
Первым делом была выбрана структура класса больших целых чисел. Так как число может быть как положительным, так и отрицательным было введено символьное поле, отвечающее за знак числа «+» или «–». Само число решено было записывать с помощью очереди с двусторонним доступом (deque) – контейнер из стандартной библиотеки шаблонов (STL). Очередь представляет собой динамический массив с множеством стандартных методов для его обработки. «Цифру» каждого разряда большого числа мы будем помещать в соответствующую ячейку массива. Например, число 12345, записанное с помощью deque<int> mas; будет выгледеть как набор элементов этого массива: mas[0] = 1, mas[1] = 2, mas[2] = 3, mas[3] = 4, mas[4] = 5. Также класс будет содержать некоторое количество методов, для решения поставленных задач. Класс будет иметь название BigInteger. Структура класса изображена на рисунке 1.
Рис. 1. Схема класса BigInteger
Далее перешли к разработке методов класса. Сначала для непосредственной работы с большими числами были реализованы методы для чтения числа из консоли и печати в консоль – chtenie() и vector_print(BigInteger) соответственно.
Метод chtenie() считывает в виде строки данные введенные в консоль. Затем проверяет первый символ строки на наличие знака «–». Потом посимвольно, используя вспомогательную строку, содержащую цифры («0123456789»), заносит каждую цифру в конец очереди-массива. На выходе мы получаем большое число, содержащее знак «», либо «–». Также в методе используется вспомогательный метод dell_null(BigInteger), который возвращает число, удаляя впереди стоящие ничего не значащие нули (т.е. 00123 –> 123).
Метод vector_print(BigInteger) выполняет печать в консоль числа, предварительно задействовав, описанный выше вспомогательный метод dell_null(BigInteger). Сначала происходит печать знака числа, затем, используя цикл, выполняется печать каждого элемента очереди-массива. Результаты работы методов представлены на рисунке 2.
Рис. 2. Ввод-вывод большого положительного и отрицательного числа в консоль
Затем был реализован метод сложения двух больших чисел summa (BigIneger, BigInteger). Сначала метод проверяет знаки переданных ему чисел, если знаки разные, он, немного модифицируя знаки, передает числа методу, вычисляющему разность двух больших чисел, речь о котором пойдет дальше. Если же знаки чисел одинаковые, непосредственно происходит операция их сложения. Принцип основан на сложении «столбиком». Находим «длину» минимального по разрядам числа, затем складываем поразрядно числа в пределах этой «длины», добавляя 1, если сумма на предыдущем шаге была > 9, находим остаток от деления полученного числа на 10 (int% 10) и записываем его в разряд, над которым выполнялась операция. После того, как разряды у одного из чисел закончатся, «добиваем» результирующее число цифрами из оставшихся разрядов большего числа. Естественно, чтобы произвести операцию с первым разрядом, нужно обратиться к последнему элементу нашей очереди массива. Пример сложения представлен на рисунке 3.
Рис. 3. Операция сложения
Следующей операцией над большими числами стала операция вычитания, представленная методом rasnost (BigInteger, BigInteger). Вначале метод проверяет знаки переданных ему чисел, если знаки чисел равные (с учетом знака разности), то метод передает числа методу summa (BigInteger, BigInteger). Например, 12 – (-7). Метод передаст 12 и 7 для обработки методу summa (BigInteger, BigInteger). Если знаки чисел разные, то происходит операция вычитания. Принцип основан на вычитании «столбиком». Находим число с меньшим количеством разрядов (меньшей «длиной»), ставим его вторым. И начинаем поразрядно вычитать. При этом, если в разряде первого числа значение больше, чем в разряде второго числа, прибавляем к разности этих чисел 10. Но на следующем шаге вычитаем 1 из следующего полученного результата поразрядного вычитания. Выполняем эти действия, пока не закончатся разряды наименьшего числа, затем «добиваем» результирующее число цифрами из оставшихся нетронутыми разрядов большего числа. Пример вычитания представлен на рисунке 4.
Рис. 4. Операция вычитания
После того, как были реализованы операции сложения и вычитания, перешли к написанию операции умножения, которую выполняет метод proisvedenie (BigInteger, BigInteger). Также в его основе лежит принцип умножения «столбиком». Выбираем одно из больших чисел, и поэтапно умножаем числа из каждого разряда этого большого числа, на другое большое число. В результате на каждом шаге у нас получаются «промежуточные» большие числа, суммируя которые с помощью описанного выше метода summa (BigInteger, BigInteger) мы получаем необходимый нам результат. При этом не забываем в зависимости от разряда множителя «добивать» начальные разряды «промежуточных» больших чисел нулями. Как и в предыдущих операциях при поразрядном перемножении в результат мы записываем остаток от деления на 10 и, если результат поразрядного перемножения больше либо равен 10, то на следующем шаге перемножения мы прибавляем число равное целой части от деления предыдущего результата на 10. Также для ускорения процесса перемножения были выделены особые случаи – умножение на 0 и на 1. Пример перемножения двух больших чисел представлен на рисунке 5.
Рис. 5. Операция умножения
После реализации метода перемножения двух больших чисел операции возведения числа в степень и операция взятия факториала числа не представляют большой трудности, так как могут быть выражены через умножение. Метод stepen (BigInteget, int), представляющий операцию возведения в степень большого числа, принимает в качестве аргументов само большое число и целое число, задающее степень, в которую необходимо возвести большое число. Метод вызывает операцию перемножения числа на само себя в цикле, количество шагов которого равно заданной степени. После выполнения данного цикла получаем нужную нам степень большого числа. Метод factorial(BigInteger), представляющий операцию получения факториала большого числа, мог быть выполнен двумя способами: используя рекурсию или используя итерацию, т.е. цикл. Был выбран второй вариант, так как он более производительный и не требует повторного вызова метода factorial(BigInteger), что замедляло бы работу программы. Для перемножения здесь использовалось вспомогательное большое число, которое изначально приравнивалось к числу, факториал которого нужно было найти. Затем на каждом шаге итерации оно уменьшалось на 1. На каждом шаге это число умножалось на ранее полученный результат, т.е. получалась выражение вида N!=((N*N-1)*N-2*)…*1. После выполнения данного цикла получаем факториал заданного числа.
Рисунок 6. Вычисление факториала 1000
Построение проекта осуществлялось в режиме Release. Технические характеристики компьютера, на котором выполнялись расчеты, представлены на рисунке 7.
Рисунок 7. Технические характеристики
Для того, чтобы исключить возможное влияние операционной системы на время выполнения вычисления, был проведен численный эксперимент, результаты которого представлены в таблице 1.
Таблица 1. Время вычисления факториала 1000
| Порядковый номер вычисления | Время вычисления, сек |
| 1 | 2,446 |
| 2 | 2,448 |
| 3 | 2,426 |
| 4 | 2,451 |
| 5 | 2,441 |
| 6 | 2,442 |
| 7 | 2,442 |
| 8 | 2,443 |
| Среднее время вычисления | 2,442 |
Таким образом, программа вычисляет факториал 1000 в среднем за 2,442 секунды.
Пожалуй, самой сложной для реализации, является операция деления и нахождение остатка от деления двух больших чисел. Методы соответствующие данным операциям были названы delenie (BigInteger, BigInteger) и ostasok_delenie (BigInteger, BigInteger) соответсвенно. В основе лежит принцип деления «столбиком». Пример работы алгоритма приведен на рисунке 8.
Рис. 8. Операция деления и нахождение остатка от деления
Ход алгоритма следующий: сравниваем делитель с делимым, прибавляя поразрядно по одной цифре к делителю в случае, если получившийся делитель меньше делимого, при этом в частное записываем 0. На рисунке 8 видно этот этап: 2<7985, в частное записываем 0, затем 21<7985, в частное записываем 0, и так далее пока не поменяется знак неравенства 21367>7985. После этого запускается цикл по нахождению следующей цифры частного. На каждом шаге делитель прибавляется на величину равную самому делителю, пока он не станет больше либо равен нашему промежуточному делимому, т.е. 21367. Шаг цикла, на котором выполнится данное условие, и будет искомой цифрой для частного. Затем вычитаем из промежуточного делимого полученное в ходе цикла число и получаем промежуточный остаток. Так как он точно меньше делителя (в связи с предыдущими условиями), добавляем к нему следующую не задействованную цифру делимого и переходим к первому шагу алгоритма. Алгоритм считается выполненным, если получается остаток, меньший делителя и не осталось ни одной незадействованной цифры делимого. В зависимости от задачи, метод возвращает либо частное, либо остаток от деления.
Для удобства пользователей был введен еще один метод vishislenie(), который предоставляет возможность выполнять вышеперечисленные арифметические операции с двумя или одним большим числом путем простого ввода необходимого для вычисления выражения. Пример работы данного метода приведен на рисунке 9.
факториал большой число перемножение
Рис. 9. Режим вычисления выражений
Выводы
Таким образом, в ходе написания программы, поставленные задачи были полностью выполнены: сделаны механизмы чтения и печати в консоль больших чисел, реализованы арифметические операции. Производительность программы, на мой взгляд, достаточно высокая, что было достигнуто за счет некоторой оптимизации кода (в основном в результате переработки операции произведения). Небольшое замедление программы возможно вследствии того, что использован контейнер стандартной библиотеки шаблонов. Этот недостаток компенсируется простотой использования стандартного контейнера и множеством поставляемых с ним методов отладки, проверкой ошибок на этапе компиляции программы и механизмом исключений. Немаловажным является реализация метода предоставляющего пользователям в удобной форме производить вычисления с большими целыми числами.
Список используемой литературы
1. Лаптев В.В., Морозов А.В. «Объектно-ориентированное программирование. Задачи и упражнения». Издательство: «Питер» 2007 г.
2. Лафоре Р. «Объектно-ориентированное программирование в С++». Издательство: «Питер», 2004 г.
Приложение
Листинг 1. Файл BigInteger.h класс BigInteger.
#include <iostream>
#include <deque> // очередь (избиблиотеки STL)
#include <string>
using namespace std;
class BigInteger {
deque<int> vect; // «содержит» число
char znak; // знак числа
public: BigInteger()
{
vect = deque<int>();
znak = ' ';
}
// ___________________ Сравнение модулей больших чисел____________
int sravnenie (BigInteger big1, BigInteger big2)
{
if (big1.vect.size() > big2.vect.size()) return 1; // 1, еслипервоечисло > второго
if (big1.vect.size() < big2.vect.size()) return -1; // -1, еслипервоечисло < второго
if (big1.vect.size() == big2.vect.size())
{
for (int i = 0; i < (int) big1.vect.size(); i++)
{
if (big1.vect.at(i) > big2.vect.at(i)) return 1;
if (big1.vect.at(i) < big2.vect.at(i)) return -1;
}
return 0; // 0, если числа равны
}
}
// ___________________ Чтение числа из консоли ___________________
BigInteger chtenie()
{
BigInteger big;
string temp = «0123456789»; // вспомогательнаястрока
string minus = «–»;
string str;
cin >> str;
if (str.at(0) == minus.at(0)) big.znak = '-'; // определение знака числа
for (int i = 0; i < (int) str.length(); i++) // циклсчитывающийцифрыизстроки
for (int j = 0; j < 10; j++)
if (str.at(i) == temp.at(j)) big.vect.push_back(j);
return dell_null(big);
}
// ___________________ Функция удаления нулей из начала числа ____
BigInteger dell_null (BigInteger big)
{
while (big.vect.size() > 1)
{
if (big.vect.at(0)!= 0) break;
else {big.vect.pop_front();}
}
return big;
}
// ___________________ Печать числа в консоль ____________________
void vector_print (BigInteger big)
{
big = dell_null(big); // убираем нули из начала числа
if (big.vect.size() == 1 && big.vect.at(0) == 0) big.znak = ' '; // если число равно 0, то не ставим знак
if (big.znak == '-') // если число отрицательное, сначала печатаем знак –
cout << big.znak;
for (int i = 0; i < (int) big.vect.size(); i++)
cout << big.vect.at(i);
}
// ___________________ Суммабольшихчисел _______________________
BigInteger summa (BigInteger big1, BigInteger big2)
{
if (big1.znak!= big2.znak) // если разные знаки, то отправляем на метод разность
{
if (big1.znak == '-') // заменяем– x+y на y-x
{
big1.znak = ' ';
return rasnost (big2, big1);
}
else // заменяем x+-y на x-y
{
big2.znak = ' ';
return rasnost (big1, big2);
}
}
deque<int> summa = deque<int>(); // сюда записывается результат
int temp = 0; // 1 для добавления к старшему разряду
int metka = 0; // для вычисления позиции, с которой остаются разряды только одного числа
if (big1.vect.size() >= big2.vect.size()) // ставим большее число на первое место
{
for (int i = big1.vect.size() – 1, j = big2.vect.size() – 1; j >=0; i–, j–) // начиная с первых разрядов складываем числа
{
summa.push_front((big1.vect.at(i) + big2.vect.at(j) + temp)%10);
if ((big1.vect.at(i) + big2.vect.at(j) + temp) >= 10) temp = 1; else temp = 0; // прибавляем 1 наследующемшаге, еслисуммабольше 10
metka = i;
}
for (int i = metka-1; i >= 0; i–) // начиная с позиции метки добиваем цифрами из большего числа, учитывая возможное прибавление 1
{
summa.push_front((big1.vect.at(i)+temp)%10);
if ((big1.vect.at(i) + temp) == 10) temp = 1; else temp = 0;
}
if (temp == 1) summa.push_front(1); // срабатыва
}
else
{
for (int i = big2.vect.size() – 1, j = big1.vect.size() – 1; j >=0; i–, j–)
{
summa.push_front((big2.vect.at(i) + big1.vect.at(j) + temp)%10);
if ((big2.vect.at(i) + big1.vect.at(j) + temp) >= 10) temp = 1; else temp = 0;
metka = i;
}
for (int i = metka-1; i >= 0; i–)
{
summa.push_front((big2.vect.at(i)+temp)%10);
if ((big2.vect.at(i) + temp) == 10) temp = 1; else temp = 0;
}
if (temp == 1) summa.push_front(1);
}
big1.vect = summa;
return big1;
}
// ________________________ Разностьбольшихчисел ________________
BigInteger rasnost (BigInteger big1, BigInteger big2)
{
if (big2.znak == '-') big2.znak = ' '; // x–y преобразуем в x+y и передаем в метод суммы
else big2.znak = '-';
if (big1.znak == big2.znak) return summa (big1, big2); // – x-y преобразуемв– (x+y) передаемметодусуммы
deque<int> rasn = deque<int>(); // сюда записывается разность
int temp = 0; // 1 для вычитания из старшего разряда
int metka = 0; // для вычисления позиции, с которой остаются разряды только одного числа
big1 = dell_null(big1); // предварительно удаляем незначащие нули из начала числа
big2 = dell_null(big2);
if (sravnenie (big1, big2)!= -1) // ставим большее число сверху в столбике
{
for (int i = big1.vect.size() – 1, j = big2.vect.size() – 1; j >=0; i–, j–)
{
if ((big1.vect.at(i) – big2.vect.at(j) + temp) >= 0) // поразрядновычитаем
{
rasn.push_front (big1.vect.at(i) – big2.vect.at(j) + temp);
temp = 0;
}
else
{
rasn.push_front (big1.vect.at(i) – big2.vect.at(j) + 10 + temp); // заимствуем 1 изстаршегоразряда
temp = -1;
}
metka = i;
}
for (int i = metka-1; i >= 0; i–) // добиваем числами оставшихся разрядов, учитывая -1
{
rasn.push_front (abs((big1.vect.at(i)+temp+10)%10));
if ((temp == -1) && (big1.vect.at(i) + temp) < 0) temp = -1; else temp = 0;
}
big1.vect = rasn;
return big1;
}
else
{
for (int i = big2.vect.size() – 1, j = big1.vect.size() – 1; j >=0; i–, j–)
{
if ((big2.vect.at(i) – big1.vect.at(j) + temp) >= 0)
{
rasn.push_front (big2.vect.at(i) – big1.vect.at(j) + temp);
temp = 0;
}
else
{
rasn.push_front (big2.vect.at(i) – big1.vect.at(j) + 10 + temp);
temp = -1;
}
metka = i;
}
for (int i = metka-1; i >= 0; i–)
{
rasn.push_front (abs((big2.vect.at(i)+temp+10)%10));
if ((temp == -1) && (big2.vect.at(i) + temp) < 0) temp = -1; else temp = 0;
}
big2.vect = rasn;
return big2;
}
}
// _______________________ Произведениебольшихчисел _____________
BigInteger proisvedenie (BigInteger big1, BigInteger big2)
{
BigInteger proisv;
proisv.vect.push_back(0);
BigInteger reserv;
BigInteger reserv2;
for (int i = big1.vect.size() – 1, count = 0; i >= 0; i –, count++)
{
if (big1.vect.at(i) == 0) {} // умножениена 0
else
if (big1.vect.at(i) == 1) // умножение на 1, просто прибавляем число с «добитыми» нулями
{
reserv2.vect = big2.vect;
for (int k = 0; k < count; k++) // добиваем нулями в зависимости от разряда умножения
reserv2.vect.push_back(0);
proisv = summa (reserv2, proisv);
}
else
{
int temp = 0;
for (int k = 0; k < count; k++) // добиваемнулями
reserv.vect.push_front(0);
for (int j = big2.vect.size() – 1; j >=0; j–) // умножаемпервоечислона«цифру» изразрядаучитывая temp
{
reserv.vect.push_front((big1.vect.at(i)*big2.vect.at(j) + temp)%10);
if ((big1.vect.at(i)*big2.vect.at(j) + temp) >=10) temp = (big1.vect.at(i)*big2.vect.at(j) + temp)/10; else temp = 0;
}
if (temp!=0) reserv.vect.push_front(temp); // приувеличенииразрядовчисла
proisv = summa (reserv, proisv); // складываем предыдущие результаты
reserv.vect.clear();
}
}
if (big1.znak!= big2.znak)
proisv.znak = '-';
return proisv;
}
// __________________ Возведение в степень большого числа _________
BigInteger stepen (BigInteger big, int steps)
{
BigInteger step;
//deque<int> step = deque<int>();
step.vect = big.vect; // постоянный множитель
for (int i = 1; i < steps; i++) // числошаговравноестепени
big = proisvedenie (big, step);
if (steps% 2 == 0)
big.znak = ' ';
return big;
}
// __________________ Факториал большого числа ____________________
BigInteger faktorial (BigInteger big)
{
big.znak = ' ';
BigInteger fak;
fak.vect.push_back(1);
BigInteger edinica;
edinica.vect.push_back(1); // дляуменьшенияна 1
{
while (big.vect.size()!= 0 && big.vect.at(0)!= 0) // пока число не стало равным 0
{
fak = proisvedenie (big, fak);
big = rasnost (big, edinica);
big = dell_null(big);
fak = dell_null(fak);
}
}
return fak;
}
// __________________ Деление больших чисел _______________________
BigInteger delenie (BigInteger delimoe, BigInteger delitel)
{
BigInteger chastnoe;
BigInteger ostatok;
BigInteger reserv2;
BigInteger reserv3;
reserv2.vect = delitel.vect;
for (int i = 0; i < (int) delimoe.vect.size(); i++)
{
ostatok = dell_null(ostatok);
ostatok.vect.push_back (delimoe.vect.at(i)); // промежуточныйостаток
if (sravnenie (ostatok, delitel) == -1) {chastnoe.vect.push_back(0);} // покапромежуточныйостатокбольшеделителяпишемвчастное 0
else
{
for (int j = 0; j < 10; j++) // цикл, формирующий цифры частного
{
if (sravnenie (ostatok, reserv2) == -1) // промежуточный остаток меньше делителя*j
{
chastnoe.vect.push_back(j);
ostatok = rasnost (ostatok, reserv3);
reserv2.vect = delitel.vect;
break;
}
if (sravnenie (ostatok, reserv2) == 0) // промежуточныйостатоккратныйделителю
{
chastnoe.vect.push_back (j+1);
ostatok.vect.clear();
reserv2.vect = delitel.vect;
break;
}
reserv3 = reserv2;
reserv2 = summa (reserv2, delitel); // прибавляем сам делитель, пока не станет больше остатка
}
}
} // цифры делимого заканчиваются и остаток меньше делимого, цикл завершается
if (delimoe.znak!= delitel.znak) chastnoe.znak = '-';
return chastnoe;
}
// __________________ Остаток от деления больших чисел ____________
BigInteger ostatok_delenie (BigInteger delimoe, BigInteger delitel)
{ // все как в методе delenie(), только возвращаем не частное, а остаток
BigInteger chastnoe;
BigInteger ostatok;
BigInteger reserv2;
BigInteger reserv3;
reserv2.vect = delitel.vect;
for (int i = 0; i < (int) delimoe.vect.size(); i++)
{
ostatok = dell_null(ostatok);
ostatok.vect.push_back (delimoe.vect.at(i));
if (sravnenie (ostatok, delitel) == -1) {chastnoe.vect.push_back(0);}
else
{
for (int j = 0; j < 10; j++)
{
if (sravnenie (ostatok, reserv2) == -1)
{
chastnoe.vect.push_back(j);
ostatok = rasnost (ostatok, reserv3);
reserv2.vect = delitel.vect;
break;
}
if (sravnenie (ostatok, reserv2) == 0)
{
chastnoe.vect.push_back (j+1);
ostatok.vect.clear();
reserv2.vect = delitel.vect;
break;
}
reserv3 = reserv2;
reserv2 = summa (reserv2, delitel);
}
}
}
if (ostatok.vect.size() == 0) ostatok.vect.push_back(0);
return ostatok;
}
// _________ Метод для использования выражений для вычисления _____
BigInteger vichislenie()
{
BigInteger big1;
BigInteger big2;
string temp = «0123456789»;
string snaki = «-+*/%!^»;
string str;
cin >> str; // считываем строку и в зависимости от знака выбираем действие с числами через switch
int perekluchatel = -1;
if (str.at(0) == snaki.at(0)) big1.znak = '-';
for (int i = 0; i < (int) str.length(); i++)
{
for (int j = 0; j < 10; j++)
{
if ((perekluchatel == -1) && (str.at(i) == temp.at(j))) {big1.vect.push_back(j); break;}
if ((perekluchatel!= -1) && (str.at(i) == temp.at(j))) {big2.vect.push_back(j); break;}
}
if (perekluchatel == -1)
for (int j = 0; j < 7; j++)
{
if ((str.at(i) == snaki.at(j)) && (i!= 0))
{
perekluchatel = j;
if (perekluchatel == 5) break;
if (str.at (i+1) == snaki.at(0)) big2.znak = '-'; break;
}
}
}
cout << str << «=»;
switch(perekluchatel)
{
case 0:
{
return rasnost (big1, big2); break;
}
case 1:
{
return summa (big1, big2); break;
}
case 2:
{
return proisvedenie (big1, big2); break;
}
case 3:
{
return delenie (big1, big2); break;
}
case 4:
{
return ostatok_delenie (big1, big2); break;
}
case 5:
{
return faktorial(big1); break;
}
case 6:
{
BigInteger edinica;
edinica.vect.push_back(1);
BigInteger dvoika;
dvoika.vect.push_back(2);
BigInteger step;
step.vect = big1.vect;
BigInteger tempbig2;
tempbig2.vect = big2.vect;
big2.znak = ' ';
while (big2.vect.size()!= 0 && big2.vect.at(0)!= 1)
{
big1 = proisvedenie (big1, step);
big2 = rasnost (big2, edinica);
big2 = dell_null(big2);
}
BigInteger proverka = ostatok_delenie (tempbig2, dvoika);
if (proverka.vect.at(0) == 0)
big1.znak = ' ';
return big1;
break;
}
}
}
};
Листинг 2. Файл Main.cpp
#include <clocale>
#include «BigInteger.h» // подключаемклассбольшихцелыхчисел
void main() // функция использующая большие целые числа
{
setlocale (LC_CTYPE, «Russian»);
BigInteger bint1;
BigInteger bint2;
BigInteger summ;
BigInteger rasn;
BigInteger proisv;
BigInteger step;
BigInteger fak;
BigInteger chastnoe;
int x, y; // переключатели режима вычисления
bool flag = true;
cout << «Выберите режим вычисления:n1 – режим выраженияn2 – режим выбора операцииn ->»;
cin >> y;
if (y == 1)
{
cout << «Введите выражение для вычисления:n»;
while (true)
{
BigInteger resultat;
resultat = resultat.vichislenie();
resultat.vector_print(resultat);
cout << endl;
}
}
else
{
cout << «Введите первое число:»;
bint1 = bint1.chtenie();
cout << «Введите второе число:»;
bint2 = bint2.chtenie();
while (flag == true)
{
cout << «nnВведите номер операции: n»;
cout << «1 – сложение чисел n»;
cout << «2 – разность чисел n»;
cout << «3 – умножение чисел n»;
cout << «4 – деление чисел n»;
cout << «5 – остаток от деления чисел n»;
cout << «6 – возведение в степень n»;
cout << «7 – факториал n»;
cout << «8 – ввести новые числаn»;
cout << «9 – выйти из программыn»;
cout << «->»;
cin >> x;
switch(x)
{
case 1:
{
cout << «nСуммачисел:»;
summ = summ.summa (bint1, bint2);
summ.vector_print(summ);
break;
}
case 2:
{
cout << «nРазностьчисел:»;
rasn = rasn.rasnost (bint1, bint2);
rasn.vector_print(rasn);
break;
}
case 3:
{
cout << «nПроизведениечисел:»;
proisv = proisv.proisvedenie (bint1, bint2);
proisv.vector_print(proisv);
break;
}
case 4:
{
cout << «nДелениечисел:»;
chastnoe = chastnoe.delenie (bint1, bint2);
chastnoe.vector_print(chastnoe);
break;
}
case 5:
{
cout << «nОстаток от деления чисел:»;
chastnoe = chastnoe.ostatok_delenie (bint1, bint2);
chastnoe.vector_print(chastnoe);
break;
}
case 6:
{
int st;
cout << «Введите в какую степень нужно возвести первое число:»;
cin >> st;
cout << «n» << st <<» – аястепеньчисла:»;
step = step.stepen (bint1, st);
step.vector_print(step);
break;
}
case 7:
{
cout << «nФакториал первого числа:»;
fak = fak.faktorial(bint1);
fak.vector_print(fak);
break;
}
case 8:
{
bint1 = BigInteger();
cout << «nВведитепервоечисло:»;
bint1 = bint1.chtenie();
bint2 = BigInteger();
cout << «Введите второе число:»;
bint2 = bint2.chtenie();
break;
}
case 9:
{
flag = false;
break;
}
default:
{
cout << «nОшибка ввода, повторите процедуру!»;