//done by smallrain . 05,4,7
由于程序太长，分多次贴
#include<iostream>
#include<fstream>
#include<string>
#include"time.h"
using namespace std;


struct cresi                                     //此结构体用来存余数,并打印
{
    int *p_resi;                                 //指向内存中存放余数的连续空间
    int len_resi;                                //余数存放空间的长度
    void print()                                 //打印余数
    {
        for(int i=len_resi-1;i>=0;i--)
        {
            cout<<p_resi[i];
        }
        cout<<endl;
    }
};///:p

struct cresi resi;                               //定义结构体全局变量,用于处理高精度整数除法的余数
    
class cata                                       //定义高精度类,可实现任意大数的四则运算
{
public:

    cata(int Max=10);
    ~cata();
    bool empty() const;

    int length() const;                          //存放高精度数的数组的长度

    void printcata(ofstream &out) const;
    void pricata();                              //打印高精度数
    void del_first();                            //删除高精度数组的首单元

    cata &getdata(const string &x);              //由于数据读入用的是string,把字符串转化为整形数组,并且完成逆置

    cata &operator +(const cata &y);             //实现高精度的加法,结果存放于被加数中,且返回被加数对象的指针
    cata &operator -(const cata &y);             //实现高精度的减法,结果存放于被减数中,且返回被减数对象的指针
    cata &operator *(const cata &y);             //实现高精度的乘法,结果存放于被乘数中,且返回被乘数对象的指针
    cata &operator /(const cata &y);             //实现高精度的除法,结果存放于被除数中,且返回被除数对象的指针
    cata &operator =(const cata &y);             //重载赋值运算符,用以实现cata对象的赋值

    friend bool dispose_boundary(const cata &m,const cata &n);        //处理边界情况
    friend int compare_cata(const cata &x,const cata &y);             //比较两个高精度数的大小
    friend void result(cata &m,cata &n,cata &result_combination,cata &result_catalan); //产生大组合数结果和catalan数结果
    friend void boundary_result(cata &m,cata &result_combination,cata &result_catalan); //在边界条件下产生上述结果

private:
    int n;                                       //存放高精度数的数组的长度
    int displacement;                            //数组偏移量,用于除法移位
    int MaxSize;
    int *data;                                   //用于申请动态空间,指向存放高精度数的数组
};///:p

inline cata::cata(int Max)                       //构造函数
{
    MaxSize=Max;
    data=new int[MaxSize];
    n=0;
    displacement=0;
}///:p

inline cata::~cata()                             //析构函数
{
    delete [] data;
}///:p

inline bool cata::empty() const                  //判断是否非空,在本程序中无用
{
    return n==0;
}///:p

inline bool dispose_boundary(const cata &m,const cata &n)
{
    if(((1==n.n)&&(n.data[0]==0))||compare_cata(m,n)==2)
    {
        return false;
    }
    else
    {
        return true;
    }
}///:p

inline int cata::length() const                  //返回高精度数的长度,即是数组长度
{
    return n;
}///:p

inline void cata::del_first()                    //删除存放高精度数的数组的首单元,在除法中运用
{
    /*for(int i=1;i<n;i++)
    {
        data[i-1]=data[i];
    }*/
    displacement+=1;
    n-=1;
}///:p

void cata::pricata()                             //打印高精度数到控制台
{
    for(int i=n-1;i>=0;i--)
    {
        cout<<data[i];
    }
    cout<<endl;
}///:p

cata &cata::getdata(const string &str)           
{
    int len_int=str.length(),len_str=len_int;    
    if(this->n!=len_int)
    {
        delete [] data;
        data=new int [len_int];
        if(NULL==data)
        {
            cout<<"the error take place in getdata()"<<endl;
            exit(1);
        }
    }
    for(int j=0;j<len_int;j++)                  //完成string到int型数组的转换,并且逆置
    {
        data[j]=(int)(str[len_str-1-j]-48);
    }
    n=len_int;
    return *this;
}///:p