Р.insert(Р.end О, LenNew - LenOld, 0); else if (LenNew < LenOld)

P.erase(P.begin()+LenNew, P.end());

Удалить все старшие нули (в конце вектора Р): void large::reduce() { int L = P.size();

while (L > 0 && P[L-1] == 0) L--;

P. erase (P. begin 0 + L, P.endO);

if (L == 0) neg = 0;

Разные конструкторы: large::large(const char *str) { bool Neg = *str == - ;

int i = (Neg ? 1 : 0) ;

*this = 0;

while (str[i])

*this = *this * 10 + (str[i + + ] - 0 ) ;

neg = Neg;

reduce();

large::large(int i)

{ if (i > 0) P.push back(i); else

if (i < 0) P.push back(-i);

neg = i < 0;

large::large(long L) { neg = L < 0;

unsigned long UL = neg ? -L : L;

if (UL != 0)

#if LONG MAX == INT MAX

sizeof(long) == sizeof(int): P.push back(uint(UL));

#else

sizeof(long) > sizeof(int): while (UL != 0)

{ P.push back(uint(UL & UINT MAX)); UL = wLen;

#endif }

large::large(uint i) { neg = 0;

Operator + определяется через += и т. п.:

large operator+(large x, const large &y){return x+=y;}

large operator-(large x, const large &y){return x-=y;}

large operator*(large x, const large &y){return x*=y;}

large operator/(large x, const large &y){return x/=y;)

large operator%(large x, const large &y){return x%=y;}

large operator<<(large u, uint k){return u <<= k;}

large operator (large u, uint k) {return u = k;}

large large::operator-()const { large v = *this;

if (v.P.sizeO) v.neg = Iv.neg;

return v;

large &large::operator+=(const large &y) { if (neg != y.neg) return *this -= -y;

int i, Ly = y.P.sizeO ;

uint d, carry = 0; Длина результата = max. длин операндов + 1:

SetLen(max(Ly, (int)P.size()) + 1} ;

int L = P.size();

for (i=0; i<L; i++)

{ if (i >= Ly && carry == 0) break; d = P[i] + carry;

Сбросить признак переноса carry в О, если

последнее сложение не привело

к дополнительному переносу:

carry = d < carry;

if (i < Ly)

{ P[i] = d + y.P[i];

Последнее сложение может привести к переносу,

только если текущий перенос carry равен О

(и d > 0):

if (P[i] < d) carry = 1; } else P[i] = d;

reduce(); return *this;

large &large::operator-=(const large &y) { if (neg != y.neg) return *this += -y;

if (!neg &£e у > *this I neg && у < *this) return *this = -(y - *this);

int i, borrow = 0, Ly = y.P.sizeO, L = P.sizeO;

if (i) P.pkush back(i) ;

uint d;

for (i=0; i<L; i++)

{ if (i >= Ly && borrow == 0) break; d = P[i] - borrow; borrow = d > P[i]; if (i < Ly) { P[i] = d - y.P[i];

if (P[i] > d) borrow = 1; } else P[i] = d;

reduce(); return *this;

large &large::operator*=(int y) { bool Neg = у < 0;

if (Neg) у = -у;

*this *= uint(y);

if (Neg)

neg = !neg;

return *this;

large &large::operator*= (uint y) { int lenO = P.sizeO, i;

uint Hi, Lo, dig = P[0], nextdig = 0;

SetLendenO + 1) ;

for (i=0; i<lenO; i++)

{ Вычислим произведение двух цифр dig * у; результатом является (Hi, Lo): DDproduct(dig, у. Hi, Lo); P[i] = Lo + nextdig; dig = P[i+1];

nextdig = Hi + (P[i] < Lo) ;

P[i] = nextdig; reduce(); return *this;

large &large::operator*=(large y)

{ int L = P.sizeO, Ly = y.P.sizeO;

if (L == 0 II Ly == 0) return *this = 0;

bool DifSigns = neg != y.neg;

if (L + Ly == 2)

L = Ly = 1: Произведение длиной в одну или две цифры: { uint а = Р[0], b = у.Р[0];

Р[0] =а*Ь; Предположим произведение длиной в одну цифру: