Создайте методы для арифметических действий на числами класса verylong

// verylong.h
// описатель класса сверхбольших целых чисел
#include <iostream>
#include <string.h> // для strlen()и т. п.
#include <stdlib.h> // для ltoa()
using namespace std;
const int SZ = 1000; // максимальное число разрядов
class verylong
{
private:
char vlstr[SZ]; // число как строка
int vlen; // длина строки verylong
verylong multdigit(const int) const; // прототипы
verylong mult10(const verylong) const;// скрытых
// функций
public:
verylong() : vlen(0) // конструктор без аргументов
{ vlstr[0] = '\0'; }
verylong(const char s[SZ]) // конструктор (1 аргумент)
{ strcpy(vlstr, s); vlen = strlen(s); } // для строки
verylong(const unsigned long n) // конструктор (1 арг.)
{ // для long int
ltoa(n, vlstr, 10); // перевести в строку
strrev(vlstr); // перевернуть ее
vlen = strlen(vlstr); // найти длину
}
void putvl() const; // вывести число
void getvl(); // получить число от пользователя
verylong operator+(const verylong); // сложить числа
verylong operator*(const verylong); // умножить
};

// verylong.cpp
// реализация обработки данных типа verylong
#include "verylong.h" // заголовочный файл для verylong
//---------------------------------------------------------
void verylong::putvl() const // вывод на экран verylong
{
char temp[SZ];
strcpy(temp, vlstr); // создать копию
cout << strrev(temp); // перевернуть копию
} // и вывести ее
//---------------------------------------------------------
void verylong::getvl() // получить сверхбольшое число от
// пользователя
{
cin >> vlstr; // получить строку от пользователя
vlen = strlen(vlstr); // найти ее длину
strrev(vlstr); // перевернуть ее
}
//---------------------------------------------------------
verylong verylong::operator+(const verylong v)
// сложение
{
char temp[SZ];
int j;
// найти самое длинное число
int maxlen = (vlen > v.vlen) ? vlen : v.vlen;
int carry = 0; // установить в 1, если сумма >= 10
for(j = 0; j < maxlen; j++) // и так для каждой позиции
{
int d1 = (j > vlen - 1) ? 0 : vlstr[j]-'0'; // получить
// разряд
int d2 = (j > v.vlen - 1) ? 0 : v.vlstr[j]-'0';// и еще
int digitsum = d1 + d2 + carry; // сложить разряды
if(digitsum >= 10) // если перенос, то
{ digitsum -= 10; carry = 1; } // увеличить сумму на 10
else // установить перенос в 1
carry = 0; // иначе перенос = 0
temp[j] = digitsum + '0';// вставить символ в строку
}
if(carry == 1) // если перенос в конце,
temp[j++] = '1'; // последняя цифра = 1
temp[j] = '\0'; // поставить ограничитель строки
return verylong(temp); // вернуть временный verylong
}
//---------------------------------------------------------
verylong verylong::operator*(const verylong v)// умножение
{ // сверхбольших чисел
verylong pprod; // произведение одного разряда
verylong tempsum; // текущая сумма
for(int j = 0; j < v.vlen; j++)// для каждого разряда аргумента
{
int digit = v.vlstr[j]-'0'; // получить разряд
pprod = multdigit(digit); // умножить текущий на него
for(int k = 0; k < j; k++) // умножить результат на
pprod = mult10(pprod); // степень 10-ти
tempsum = tempsum + pprod; // прибавить произведение к
// текущей сумме
}
return tempsum; // вернуть полученную текущую сумму
}
//---------------------------------------------------------
verylong verylong::mult10(const verylong v) const // умножение аргумента
// на 10
{
char temp[SZ];
for(int j = v.vlen - 1; j >= 0; j--)// сдвинуться на один разряд
temp[j + 1] = v.vlstr[j]; // выше
temp[0] = '0'; // обнулить самый младший разряд
temp[v.vlen + 1] = '\0'; // поставить ограничитель строки
return verylong(temp); // вернуть результат
}
//---------------------------------------------------------
verylong verylong::multdigit(const int d2) const
{ // умножение числа на
char temp[SZ]; // аргумент (цифру)
int j, carry = 0;
for(j = 0; j < vlen; j++) // для каждого разряда
{ // в этом сверхбольшом
int d1 = vlstr[j]-'0'; // получить значение разряда
int digitprod = d1 * d2; // умножить на цифру
digitprod += carry; // добавить старый перенос
if(digitprod >= 10) // если возник новый перенос,
{
carry = digitprod / 10; // переносу присвоить значение старшего разряда
digitprod -= carry * 10;// результату - младшего
}
else
carry = 0; // иначе перенос = 0
temp[j] = digitprod + '0';// вставить символ в строку
}
if(carry != 0) // если на конце перенос,
temp[j++] = carry + '0'; // это последний разряд
temp[j] = '\0'; // поставить ограничитель
return verylong(temp); // вернуть сверхбольшое число
}

// vl_app.cpp
// вычисляет факториалы больших чисел
#include "verylong.h" // заголовочный файл verylong
int main()
{
unsigned long numb, j;
verylong fact = 1; // инициализировать verylong
cout << "\n\nВведите число: ";
cin >> numb; // ввод числа типа long int
for(j = numb; j > 0; j--)// факториал — это numb *
fact = fact * j; // numb-1 * numb-2 *
cout << "Факториал = "; // numb-3 и т. д.
fact.putvl(); // вывести значение факториала
cout << endl;
return 0;
}