Перевести из С++ в С#

//--------------------------------------------------------------------------- 
#define BASE 10000 
#define BASE_DIG 4 
#define MAX_L 50 
 
#include <conio.h> 
#include <math.h> 
#include <stdio.h> 
#include <iostream.h> 
#include <Classes.hpp> 
 
const AnsiString SET_NUM = "0123456789"; 
 
int DivRes(int dig, int size) 
{ 
  if (size%dig == 0) 
  { 
  return 0; 
  } else 
  { 
  return 1; 
  } 
} 
 
class BigInt { 
public: 
  int Size; 
  int SizeMax; 
  // Size - текущая длина 
// SizeMax - максимальная длина 
  int *Coef; 
 
  // Массив коэффициентов 
 
  BigInt(); 
  BigInt(AnsiString NUM); 
  BigInt(const BigInt&); 
 
  virtual ~BigInt(); 
 
  void zero(); // Обнулить число 
  void update(); 
 
  BigInt& operator=(const BigInt&); 
  BigInt& operator+(const BigInt& B); // сложение 
  BigInt& operator-(BigInt& B); // вычитание 
 
  // C = A-B, должно быть A.Size >= B.Size. Работает вызов Sub(A, B, A). 
// Если длины равны, но A<B: возвращается -1, результат будет дополнением. 
  int Sub (const BigInt& A, const BigInt& B, BigInt& C); 
  // Вычисление C = A+B, работает вызов вида Add (A, B, A). 
  // максимальный размер C должен быть достаточен для хранения суммы 
  void Add(BigInt &A,BigInt &B, BigInt &C); 
  void Div(const BigInt &A, BigInt &B, BigInt &Q, BigInt &R); 
 
  operator long(); // Оператор преобразования BigInt к типу long 
 
  friend ostream& operator << (ostream& os, const BigInt& A); 
 
}; 
 
//--------------------------------------------------------------------------- 
 
BigInt::BigInt() 
{ 
  SizeMax = MAX_L; 
  Size = 0; // Объявление вида BigInt A; 
  Coef = new int[SizeMax]; 
 
} 
 
//------------------------------------------------------------- 
 
BigInt::BigInt(AnsiString CH) 
{ 
  SizeMax = MAX_L; 
  Coef = new int[SizeMax]; // Объявление вида BigInt A("45345345345"); 
 
  AnsiString ctemp, coeft=""; 
  int j=0; 
 
  for (int i=1; i<=CH.Length(); i++) 
  { 
  ctemp=""; 
  ctemp+=CH[i]; 
  if (StrPos(SET_NUM.c_str(),ctemp.c_str())) 
  { 
  j++; 
  coeft+=ctemp; 
  } 
  } 
  ctemp=""; 
  while(DivRes(BASE_DIG, coeft.Length())!=0) 
  { 
  ctemp=coeft; 
  coeft=""; 
  coeft="0"+ctemp; 
  } 
  ctemp=""; 
 
  int sz = coeft.Length()/BASE_DIG; 
 
  for (int i=1; i<=sz; i++) 
  { 
  Coef[i-1]=StrToInt(coeft.SubString(coeft.Length()-4*(i)+1,4)); 
  } 
 
  Size=sz; 
} 
 
//------------------------------------------------------------- 
 
BigInt::BigInt(const BigInt &A) 
{ // Конструктор копирования 
  SizeMax = A.SizeMax; // Создает B, равное A 
  Size = A.Size; 
  Coef = new int[SizeMax]; 
  for(int i=0; i<SizeMax; i++) Coef[i] = A.Coef[i]; 
} 
//------------------------------------------------------------- 
 
BigInt::~BigInt() 
{ 
  delete Coef; 
} 
 
//------------------------------------------------------------- 
 
void BigInt::zero() 
{ // A.zero() - обнулить число 
  for(int i=0; i<SizeMax; i++) Coef[i]=0; 
  Size=1; 
} 
 
//------------------------------------------------------------- 
 
BigInt::operator long() 
{ 
  int tmp=0; // при вычислениях может произойти переполнение 
  for(int i=0; i<Size; i++) 
  tmp += Coef[i]*(long)pow(BASE, i); 
 
  return tmp; 
} 
 
//------------------------------------------------------------- 
 
inline BigInt& BigInt::operator=(const BigInt &A) { 
  const int *a = A.Coef; 
  if (this == &A) return *this; // Если присваивание вида A=A - выйти 
  if ( SizeMax < A.Size ) { // Если размера не хватает - переинициализация 
  if (Coef) delete Coef; 
  Coef = new int[A.Size]; 
  SizeMax = A.Size; 
  Size = A.Size; 
  } else Size = A.Size; 
 
  for(int l=0; l<Size; l++) 
  Coef[l] = a[l]; 
 
  return *this; 
} 
//------------------------------------------------------------- 
void Add(const BigInt &A,const BigInt &B, BigInt &C) 
{ 
  int i; 
  long temp; 
  // temp здесь и далее играет роль "временной" цифры, 
  // до выполнения переноса. Возможно, temp > BASE. 
 
const int *a=A.Coef, *b=B.Coef; 
int *c=C.Coef, carry = 0; 
  // Добиваемся 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 < 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; 
} 
 
//------------------------------------------------------------- 
// C = A-B, должно быть A.Size >= B.Size. Работает вызов Sub(A, B, A). 
// Если длины равны, но A<B: возвращается -1, результат будет дополнением. 
int Sub (const BigInt& A, const BigInt& B, BigInt& C) 
{ 
  const int *a=A.Coef, *b=B.Coef; 
  int *c=C.Coef; 
  int i; 
  long temp, carry=0; 
  if ( A.Size < B.Size ) cerr << "BigSub: size error" << endl; 
 
  for (i=0; i<B.Size; i++) { 
  temp = a[i] - b[i] + carry; 
  if (temp < 0) { 
  c[i] = temp + BASE; 
  carry = -1; 
  } else { 
  c[i] = temp; 
  carry = 0; 
  } 
  } 
 
  for (; i<A.Size; i++) { 
  temp = a[i] + carry; 
  if (temp < 0) { 
  c[i] = temp + BASE; 
  carry = -1; 
  } else { 
  c[i] = temp; 
  carry = 0; 
  } 
  } 
 
  // Размер результата может быть гораздо меньше, чем у исходного числа 
  // Устанавливаем его по первому положительному разряду 
  i = A.Size-1; 
  while ( (i>0) && (c[i]==0) ) i--; 
  C.Size = i+1; 
  return carry; 
} 
//------------------------------------------------------------- 
// C = A*B, работает вызов Smul (A, B, A). 
void SMul(const BigInt &A, const int B, BigInt &C) { 
  int i, temp; 
  const int *a=A.Coef; 
  int *c=C.Coef, carry=0; 
 
  for (i=0; i<A.Size;i++) { 
  temp = a[i]*B + carry; 
  carry = temp / BASE; 
  c[i] = temp - carry*BASE; // с[i] = temp % BASE 
  } 
 
if (carry) { 
// Число удлинилось за счет переноса нового разряда 
  c[i] = carry; 
  C.Size = A.Size+1; 
  } 
  else C.Size = A.Size; 
 
} 
//------------------------------------------------------------- 
 
// C = A*B, не работает вызов Mul(A, B, A) 
void Mul(const BigInt &A, const BigInt &B, BigInt &C) { 
  int i, j; 
  const int *a=A.Coef, *b=B.Coef; 
  int *c=C.Coef; 
  int temp, carry; 
 
  // Обнулить необходимую для работы часть C 
  for ( i=0; i <= A.Size+B.Size; i++ ) c[i]=0; 
 
  for ( i = 0; i < A.Size; i++) { 
  carry = 0; 
 
  // вычисление временного результата с одновременным прибавлением 
  // его к c[i+j] (делаются переносы) 
  for (j = 0; j < B.Size; j++) { 
  temp = a[i] * b[j] + c[i+j] + carry; 
  carry = temp/BASE; 
  c[i+j] = temp - carry*BASE; 
  } 
  c[i+j] = carry; 
  }  
 
  // Установить размер по первой ненулевой цифре  
  i = A.Size + B.Size - 1;  
  if ( c[i] == 0 ) i--;  
  C.Size = i+1;  
} 
  //------------------------------------------------------------- 
 
// Q = A/B , R = A%B, A, Q – длинные числа, B, R - базового типа  
void SDiv(const BigInt &A, const int B, BigInt &Q, int &R) { 
  int r=0, *q=Q.Coef; 
  const int *a=A.Coef; 
  long i, temp; 
 
  for ( i=A.Size-1; i>=0; i--) { // идти по A, начиная от старшего разряда 
  temp = r*BASE + a[i]; // r – остаток от предыдущего деления 
  // вначале r=0, temp – текущая цифра A с 
// учетом перенесенного остатка  
   
  q[i] = temp / B; // i-я цифра частного 
 
  r = temp - q[i]*B; // остаток примет участие в вычислении  
  // следующей цифры частного  
  }  
   
  R = r;  
   
  // Размер частного меньше, либо равен размера делимого  
  i = A.Size-1;  
  while ( (i>0) && (q[i]==0) ) i--;  
  Q.Size = i+1;  
 
} 
 
//------------------------------------------------------------- 
// Q = A/B, R=A%B  
void Div(const BigInt &A, BigInt &B, BigInt &Q, BigInt &R) 
{ 
  // Вырожденный случай 1. Делитель больше делимого. 
  if ( A.Size < B.Size ) { 
  Q.zero(); 
  R=A; 
  return; 
  } 
// Вырожденный случай 2. Делитель – число базового типа. 
  if ( B.Size == 1) {  
  SDiv ( A, B.Coef[0], Q, R.Coef[0]); 
  R.Size = 1;  
  return; 
  } 
// Создать временный массив U, равный A  
  // Максимальный размер U на цифру больше A, с учетом  
  // возможного удлинения A при нормализации  
  BigInt U(A.Size+1); U = A; U.Coef[A.Size]=0;  
   
// Указатели для быстрого доступа 
 
  int *b=B.Coef, *u=U.Coef, *q=Q.Coef; 
   
int n=B.Size, m=U.Size-B.Size; 
   
  long uJ, vJ, i; 
  long temp1, temp2, temp;  
 
int scale; // коэффициент нормализации 
 
  int qGuess, r; // догадка для частного и соответствующий остаток 
  int borrow, carry; // переносы 
   
// Нормализация  
  scale = BASE / ( b[n-1] + 1 );  
  if (scale > 1) {  
  SMul (U, scale, U);  
  SMul (B, scale, B);  
  }  
   
// Главный цикл шагов деления. Каждая итерация дает очередную цифру частного.  
// vJ - текущий сдвиг B относительно U, используемый при вычитании,  
// по совместительству - индекс очередной цифры частного.  
// uJ – индекс текущей цифры U  
  for (vJ = m, uJ=n+vJ; vJ>=0; --vJ, --uJ) {  
   
  qGuess = (u[uJ]*BASE + u[uJ-1]) / b[n-1]; 
  r = (u[uJ]*BASE + u[uJ-1]) % b[n-1];  
   
  // Пока не будут выполнены условия (2) уменьшать частное. 
  while ( r < BASE) { 
  temp2 = b[n-2]*qGuess;  
  temp1 = r*BASE + u[uJ-2]; 
   
  if ( (temp2 > temp1) || (qGuess==BASE) ) {  
  // условия не выполнены, уменьшить qGuess  
  // и досчитать новый остаток  
  --qGuess;  
  r += b[n-1];  
  } else break;  
  }  
   
  // Теперь qGuess - правильное частное или на единицу больше q 
  // Вычесть делитель B, умноженный на qGuess из делимого U, 
  // начиная с позиции vJ+i 
 
  carry = 0; borrow = 0; 
  int *uShift = u + vJ;  
   
  // цикл по цифрам B  
  for (i=0; i<n;i++) {  
  // получить в temp цифру произведения B*qGuess 
  temp1 = b[i]*qGuess + carry;  
  carry = temp1 / BASE; 
  temp1 -= carry*BASE;  
   
  // Сразу же вычесть из U  
  temp2 = uShift[i] - temp1 + borrow;  
  if (temp2 < 0) {  
  uShift[i] = temp2 + BASE;  
  borrow = -1; 
  } else {  
  uShift[i] = temp2;  
  borrow = 0;  
  }  
  }  
 
   
  // возможно, умноженое на qGuess число B удлинилось.  
  // Если это так, то после умножения остался  
// неиспользованный перенос carry. Вычесть и его тоже.  
  temp2 = uShift[i] - carry + borrow;  
  if (temp2 < 0) {  
  uShift[i] = temp2 + BASE;  
  borrow = -1;  
  } else {  
  uShift[i] = temp2;  
  borrow = 0; 
  }  
   
   
  // Прошло ли вычитание нормально ?  
  if (borrow == 0) { // Да, частное угадано правильно  
  q[vJ] = qGuess;  
   
  } else { // Нет, последний перенос при вычитании borrow = -1,  
  // значит, qGuess на единицу больше истинного частного  
  q[vJ] = qGuess-1;  
   
  // добавить одно, вычтенное сверх необходимого B к U  
  carry = 0;  
  for (i=0; i<n; i++) {  
  temp = uShift[i] + b[i] + carry;  
  if (temp >= BASE) {  
  uShift[i] = temp - BASE; 
  carry = 1;  
  } else {  
  uShift[i] = temp;  
  carry = 0;  
  }  
  }  
  uShift[i] = uShift[i] + carry - BASE;  
  }  
   
  // Обновим размер U, который после вычитания мог уменьшиться  
  i = U.Size-1;  
  while ( (i>0) && (u[i]==0) ) i--;  
  U.Size = i+1;  
   
  }  
  // Деление завершено !  
 
  // Размер частного равен m+1, но, возможно, первая цифра - ноль.  
  while ( (m>0) && (q[m]==0) ) m--;  
  Q.Size = m+1;  
   
  // Если происходило домножение на нормализующий множитель –  
  // разделить на него. То, что осталось от U – остаток.  
  if (scale > 1) {  
  short junk; // почему-то остаток junk всегда будет равен нулю…  
  SDiv ( B, scale, B, junk);  
  SDiv ( U, scale, R, junk);  
  } else R=U;  
} 
 
//------------------------------------------------------ 
 
//-------------------------------------------------------- 
ostream& operator << (ostream& os, const BigInt& A) 
  { 
  int j, Digit=0; 
  int Pow, Dec, Coef; 
 
  os << A.Coef[A.Size-1]; 
 
  for (int i=A.Size-2; i>=0; i--) 
  { // Цикл вывода коэффициентов 
  Pow = BASE/10; 
  Coef = A.Coef[i]; 
  for (j=0; j<BASE_DIG; j++) 
  { // Цикл, выводящий каждый коэффициент 
  Dec = Coef/Pow; 
  Coef -= Dec*Pow; 
  Pow /= 10; // Очередная цифра получается делением 
  os << Dec; // коэффициента на 10 
  Digit++; 
  } 
  } 
  return os; 
  } 
 
void main() 
{ 
  clrscr(); 
 
  BigInt A("9999"); 
  BigInt B("9999"); 
  BigInt C; 
  BigInt F; 
 
  C.zero(); 
  F.zero(); 
 
  cout << "Two BigINT number :" << endl; 
  cout << A << endl; 
  cout << B << endl; 
  Add(A,B,C); 
  cout << "Operation + :" << endl; 
  cout << C << endl; 
 
  cout << "Operation - :" << endl; 
  Sub(A,B,C); 
  cout << C << endl; 
 
  cout << "Operation BigINT * INT :" << endl; 
  SMul(B,10,C); 
  cout << "BigInt =" << B <<"* 10 =" << C << endl; 
 
  cout << "Operation BigINT * BigINT :" << endl; 
  Mul(A,B,C); 
  cout << C << endl; 
  int FI; 
  cout << "Operation BigINT / INT :" << endl; 
  SDiv(A,10,C,FI); 
 
  cout << A << "/" << "10 = " << C << " + " << FI << endl; 
 
  cout << "Operation BigINT / BigINT :" << endl; 
  Div(A,B,C,F); 
 
  cout << A << "/" << B << " = " << C << " + " << F << endl; 
 
  //cout << A.operator long() << endl; 
 
  getch(); 
 
}