классы

[fkty]

здравствуйте,только начала изучение классов,помогите с решением задачи:нужно реализовать длинные целые числа в виде класса с конструктором и деструктором,перегрузить ввод,вывод и сумму.Вот что у меня выходит,пока без перегрузок:

#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()
{
}

[fkty]

никто не сможет помочь?

[Stilet]

Ну так а что с твое точки зрения не так в коде?

[fkty]

мне кажется там вообще имеется ввиду бесконечные числа,не понимаю как вообще это реализовать

[fkty]

вот почти сделала,помогите пожалуйста доделать..

#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;
}

[nikmoon]

На самом деле задача непростая, скорее всего под длинными целыми числами нужно понимать не long int, а целые числа, которые могут иметь неограниченную длину.
Щас набросаю чо-нить )

[fkty]

nikmoon,хорошо

[nikmoon]

В общем сделал вывод и сложение чисел, ввод не делал. Сложение работает для чисел с одинаковыми знаками, для разных пока времени нет.

[nikmoon]

#include <iostream>
#include <cstring>

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 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(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;
	return 0;
}

[fkty]

nikmoon,почему то выводится ошибка,а на экране:
-555 3
-222 3
-треугольник.треугольник