#ifndef BIG_INT_CLASS_HEADER#define BIG_INT_CLASS_HEADER#include <stdio.h>#include <stdlib.h>#include <iostream>#include "cdecl.h"#if (defined(__BORLANDC__) && __BORLANDC__ < 0x550) || defined(__WATCOMC__)// Borland C++ (at least version bcc32 version 5.2 does not support the// std namespace#define std#endif/* * Big_int class * Instances of this class can represent unsigned integers of arbitrary * size. */class Big_int {public:  /*********************   * Exception classes *   *********************/  /*   * Thrown if an addition overflows or subtraction underflows   */  class Overflow { };  /*   * Thrown if Big_ints of different sizes are added, subtracted or   * compared   */  class Size_mismatch { };  /*   * Thrown if initialization fails   */  class Bad_initial_value { };  /****************   * Constructors *   ****************/  /*   * creates Big_int with given size and value   * Parameters:   *   size           - size of integer expressed as number of    *                    normal unsigned int's   *   initial_value  - initial value of Big_int as a normal unsigned int   */  explicit Big_int( size_t   size,                    unsigned initial_value = 0);  /*   * creates Big_int with given size and value   * Parameters:   *   size           - size of integer expressed as number of    *                    normal unsigned int's   *   initial_value  - initial value of Big_int as a string holding   *                    hexadecimal representation of value. (There must   *                    no other characters in string, including whitespace!)   */  Big_int( size_t       size,           const char * initial_value);  /*   * copy constructor   * Parameter:   *   big_int_to_copy - Big_int to copy   */  Big_int( const Big_int & big_int_to_copy);  /*   * Destructor   */  ~Big_int();  /*   * size method   * returns size of Big_int (in terms of unsigned int's)   */  size_t size() const;  /*   * Equals operator method   * Parameter:   *   big_int_to_copy - Big_int to copy   * Return value:   *   reference to *this* Big_int   */  const Big_int & operator = ( const Big_int & big_int_to_copy);  /********************   * Friend functions *   ********************/  /*   * friend plus operator function   * Adds two Big_int's of same size together. The result is the   * same size as the operands.   * Parameters:   *   op1 - first number to add   *   op2 - second number to add   * Return value:   *   new Big_int that is equal to op1 + op2   */  friend Big_int operator + ( const Big_int & op1,                              const Big_int & op2 );  /*   * friend subtraction operator function   * Subtracts one Big_int from another (They must have the same size.)    * The result is the same size as the operands.   * Parameters:   *   op1 - number to subtract from   *   op2 - number to subtract   * Return value:   *   new Big_int that is equal to op1 - op2   */  friend Big_int operator - ( const Big_int & op1,                              const Big_int & op2);  /*   * friend comparison operator   * Parameters:   *   op1 - first number to compare   *   op2 - second number to compare   * Return value:   *   true if op1 == op2, else false   */  friend bool operator == ( const Big_int & op1,                            const Big_int & op2 );  /*   * friend comparison operator   * Parameters:   *   op1 - first number to compare   *   op2 - second number to compare   * Return value:   *   true if op1 < op2, else false   */  friend bool operator < ( const Big_int & op1,                           const Big_int & op2);  /*   * friend output operator   * Parameters:   *   os - output stream to write to   *   op - Big_int to print value of   * Return value:   *   reference to os   */  friend std::ostream & operator << ( std::ostream &  os,                                      const Big_int & op );private:  /****************   * Private data *   ****************/  /*   * size of unsigned array   */  size_t      size_;  /*   * pointer to unsigned array holding Big_int value   */  unsigned * number_;};/************************************ * Prototypes for assembly routines * ************************************/extern "C" {  int PRE_CDECL add_big_ints( Big_int &, const Big_int &, const Big_int &) POST_CDECL;  int PRE_CDECL sub_big_ints( Big_int &, const Big_int &, const Big_int &) POST_CDECL; }/******************************** * Inline methods and functions * ********************************//* * size method * returns size of Big_int (in terms of unsigned int's) */inline size_t Big_int::size() const{  return size_;}/* * Destructor */inline Big_int::~Big_int(){  delete [] number_;}/* * friend plus operator function * Adds two Big_int's of same size together. The result is the * same size as the operands. * Parameters: *   op1 - first number to add *   op2 - second number to add * Return value: *   new Big_int that is equal to op1 + op2 */inline Big_int operator + ( const Big_int & op1, const Big_int & op2){  Big_int result(op1.size());  int res = add_big_ints(result, op1, op2);  if (res == 1)    throw Big_int::Overflow();  if (res == 2)    throw Big_int::Size_mismatch();  return result;}/* * friend subtraction operator function * Subtracts one Big_int from another (They must have the same size.)  * The result is the same size as the operands. * Parameters: *   op1 - number to subtract from *   op2 - number to subtract * Return value: *   new Big_int that is equal to op1 - op2 */inline Big_int operator - ( const Big_int & op1, const Big_int & op2){  Big_int result(op1.size());  int res = sub_big_ints(result, op1, op2);  if (res == 1)    throw Big_int::Overflow();  if (res == 2)    throw Big_int::Size_mismatch();  return result;}/************************************************** * Other inline comparison operators              * * (They use the friend comparision operators)    * **************************************************//* * comparison operator * Parameters: *   op1 - first number to compare *   op2 - second number to compare * Return value: *   true if op1 != op2, else false */inline bool operator != ( const Big_int & op1, const Big_int &op2){  return !(op1 == op2);}/* * comparison operator * Parameters: *   op1 - first number to compare *   op2 - second number to compare * Return value: *   true if op1 > op2, else false */inline bool operator > ( const Big_int & op1, const Big_int & op2){  return op2 < op1;}/* * comparison operator * Parameters: *   op1 - first number to compare *   op2 - second number to compare * Return value: *   true if op1 <= op2, else false */inline bool operator <= ( const Big_int & op1, const Big_int & op2 ){  return !(op2 < op1);}/* * comparison operator * Parameters: *   op1 - first number to compare *   op2 - second number to compare * Return value: *   true if op1 >= op2, else false */inline bool operator >= ( const Big_int & op1, const Big_int & op2){  return !(op1 < op2);}#endif