Реализовать длинные целые числа в виде класс

#include <iostream>
 
Class Maxint
{
public:
    long int nd;//число
    Maxint();//конструктор
    Maxint(Maxint & x);//конструктор копирования
    Maxint(long int n);
    ~Maxint();//деструктор
    void set_nd(long int n);
    void get_nd();
    void read();//ввод с клавиатуры
    void write();//вывод на экран
    Maxint Sum(Maxint & b);//сумма
};
 
Maxint::Maxint()
{
    nd=0;
}
 
Maxint::Maxint(Maxint & x)
{
    nd=x.get_nd();
}
 
Maxint::Maxint(long int n)
{
    nd=n;
}
 
Maxint::~Maxint()
{
}
 
void Maxint::set_nd(long int n)
{
    nd=n;
    return;
}
 
int Maxint::get_nd()
{
    return nd;
}
 
Void Maxint::read()
{
    int k;
    cout<<"введите количество длинных чисел"<<endl;
    for (int i=0;i<k;i++)
        cin>>nd;
    return;
}
 
void Maxint::write()
{
    cout<<nd;
    return;
}
 
 
Maxint Maxint::Sum(Maxint & b)
{
    Maxint s ();
        return s;
}
 
void main()
{
}

Maxint& Maxint::operator+(const Maxint& obj)
{
a=a+obj.a;
b=b+obj.b;
return *this;
}
istream& operator<<(istream& i, const Maxint& obj) // friend  в прототипе
{
std::i<<a<<std::i<<b;
}

#include <conio.h>
#include <iostream>
using namespace std;
class BigInt {
public:
// к этим членам можно закрыть доступ
long Size, SizeMax; // Size – текущая длина
                    // SizeMax – максимальная длина
short *Coef; // Массив коэффициентов
 long n;           
BigInt();
virtual ~BigInt();
void zero(); // Обнулить число
void update();
void read ();//ввод с клавиатуры
void write ();//вывод на экран
 
 
};
 
BigInt::BigInt() 
{
    SizeMax = Size = 0; // Объявление вида BigInt A;
    Coef = 0; // Создается полностью пустое число
}
BigInt::~BigInt() 
{
    delete Coef;
}
void BigInt::zero() 
{ // A.zero() – обнулить число
    for(long i=0; i<SizeMax; i++) Coef[i]=0;
    Size=1;
}
 
 
 
// Вычисление C = A+B, работает вызов вида Add (A, B, A).
// максимальный размер C должен быть достаточен для хранения суммы
void Add(const BigInt &A, const BigInt &B, BigInt &C) 
{
    long i;
    long temp; // temp здесь и далее играет роль “временной” цифры,до выполнения переноса. Возможно, temp > BASE.
// для быстрого доступа к коэффициентам объявляются временные указатели a,b,c.
    const short *a=A.Coef, *b=B.Coef;
    short *c=C.Coef, carry = 0;
    int BASE=10;
// Добиваемся B.Size ≤ A.Size.
if ( A.Size < B.Size ) 
{
    Add(B,A,C);
    return;
}
// Теперь B.Size ≤ A.Size.
// Складываем два числа, i - номер текущей цифры
for (i=0; i<B.Size; i++) 
{
    temp = a[i] + b[i] + carry;
    if (temp >= BASE) 
    { // переполнение. Перенести единицу.
        c[i] = temp - BASE;
        carry = 1;
    } 
    else 
    {
        c[i] = temp;
        carry = 0;
    }
}
// Меньшее число кончилось
for (i=0; i < A.Size; i++) 
{
    temp = a[i] + carry;
    if (temp >= BASE) 
    {
        c[i] = temp - BASE;
        carry = 1;
    } 
    else 
    {
        c[i] = temp;
        carry = 0;
    }
}
// Если остался перенос – добавить его в дополнительный разряд
if (carry) 
{
    c[i] = carry;
    C.Size = A.Size+1;
}
else C.Size = A.Size;
}
 
void BigInt::read()
{
    cin>>n;
    return;
}
 
void BigInt::write()
{
    cout<<n;
    return;
}
 
void main ()
{
 
    BigInt Z;
    cout<<"введите длинное число"<<endl;
        Z.read();
 
    getch();
    return;
}

#include <iostream>
#include <cstring>
#include <conio.h>
using namespace std;
 
#define     DEFAULT_LEN     32
 
class CLongInt
{
    char * m_Digit;     // последовательность цифр в формате little-endian (по младшему адресу - младший байт)
    int m_Len;          // длина числа в байтах
    int m_Sign;         // знак числа (0 = полож. число, -1 = отриц. число)
 
public:
    CLongInt();
    CLongInt(int _len);
    CLongInt(const char *_digit);
    ~CLongInt();
    CLongInt::CLongInt(const CLongInt &_src);
    CLongInt operator+(const CLongInt &_b);
    friend ostream &operator<<(ostream &_stream, const CLongInt &_a);
 
    int g_Len() const { return m_Len; };
};
 
 
//
//  Дефолтный конструктор
//
CLongInt::CLongInt()
{
    m_Len = DEFAULT_LEN;                // дефолтная длина длинного числа
    m_Digit = new char[DEFAULT_LEN];    // память для хранения числа
    m_Sign = 0;                         // знак числа по умолчанию
}
CLongInt::CLongInt(const CLongInt &_src)
{
    m_Len = _src.m_Len;
    m_Digit = new char[m_Len];
    strncpy(m_Digit, _src.m_Digit, m_Len);
    m_Sign = _src.m_Sign;
}
 
 
//
//  Конструктор для выделения памяти без инициализации
//
CLongInt::CLongInt(int _len)
{
    m_Len = _len;
    m_Digit = new char[_len];
    m_Sign = 0;
}
 
 
//
//  Основной конструктор
//
//  _digit - строковое представление длинного целого (со знаком или без)
//
CLongInt::CLongInt(const char *_digit)
{
    // индекс старшей цифры в переданном аргументе
    int src_index = 0;  // предполагаемое значение (если не указан знак)
 
    // проверим, указан ли знак числа в начале строки
    if (_digit[0] == '-')
    {
        m_Sign = -1;
        src_index = 1;
    }
    else
    {
        m_Sign = 0;
        if (_digit[0] == '+')
        {
            src_index = 1;
        }
    }
 
    m_Len = strlen(_digit) - src_index; // получаем длину числа в байтах
    m_Digit = new char[m_Len];          // резервируем память для хранения числа
 
 
    // индекс старшей цифры получаемого числа
    int dest_index = m_Len - 1;
 
    // преобразуем переданную строку в выбранный формат хранения длинного целого числа
    while (_digit[src_index] != 0)
    {
        m_Digit[dest_index] = _digit[src_index] - '0';  // преобразование типа '0' -> 0, '1' -> 1 и т.д.
 
        src_index++;
        dest_index--;
    }
 
}
 
//
//  Деструктор
//
CLongInt::~CLongInt()
{
    delete m_Digit;
}
 
 
//
//  Вывод длинного целого числа в поток
//
ostream &
operator<<(ostream &_stream, const CLongInt &_a)
{
    if (_a.m_Sign == -1)
        _stream << '-';
 
    for(int i = _a.m_Len - 1; i >= 0; i--)
    {
        _stream << (char)(_a.m_Digit[i] + '0');
    }
    return _stream;
}
 
 
 
CLongInt
CLongInt::operator+(const CLongInt &_b)
{
    // длина самого длинного из двух чисел
    int max_len = ((m_Len > _b.m_Len) ? m_Len : _b.m_Len);
 
    // реальная длина результата
    int res_len;
 
    // знак результата
    int res_sign;
 
    // создаем буфер
    char *buff = new char[max_len + 1];
 
    // если знаки чисел одинаковы
    if (m_Sign == _b.m_Sign)
    {
        // просто складываем числа
        int i = 0;      // индекс текущей складываемой цифры
        int carry = 0;  // признак переноса в старший разряд
        int a, b, c;
        do
        {
            // текущая цифра первого слагаемого
            if (i < m_Len)
                a = m_Digit[i];
            else
                a = 0;
 
            // текущая цифра второго слагаемого
            if (i < _b.m_Len)
                b = _b.m_Digit[i];
            else
                b = 0;
 
            // складываем с учетом возможного переноса ранее
            c = a + b + carry;
 
            // результат превышает максим. значение одной цифры
            if (c > 9)
            {
                c = c - 10;
                carry = 1;
            }
            else
            {
                carry = 0;
            }
 
            // сохраняем в буфере полученную цифру
            buff[i] = c;
 
            i++;
        }
        while(i < max_len);
 
        if (carry)
        {
            buff[i] = 1;
            res_len = max_len + 1;
        }
        else
        {
            res_len = max_len;
        }
 
        res_sign = m_Sign;
    }
    else
    {
        // будем вычитать
    }
 
    CLongInt a(res_len);
    for(int i = 0; i < res_len; i++)
        a.m_Digit[i] = buff[i];
 
    a.m_Sign = res_sign;
    delete buff;
    return a;
}
 
 
int main()
{
    CLongInt a("555");
    cout << a << " " << a.g_Len() << endl;
 
    CLongInt b("222");
    cout << b << " " << b.g_Len() << endl;
 
    cout << (a+b) << endl;
    getch();
    return 0;
}