Problem A: 自定义实数及其数组

Description

众所周知，实数在计算机内是不能精确表示的，有些实数在存储时会产生误差。为解决这个问题，对于小数部分不包含前导和后缀0的实数（0除外），可以用两个整数分别来表示其整数部分和小数部分。如：3.14，可以分解为3和14。请基于这一思想，设计一个程序，用两个整数来表示一个实数，并利用这个新的实数类型构建一个数组，实现数组的元素插入、删除和排序。
具体而言，需要定义2个类：
1.Double类。属性为2个int类型的整数，分别为实数的整数部分和小数部分。如：原来的实数为3.14，则Double类的两个属性分别是3、14。其方法至少包括：可以接收2个整数作为参数的构造函数、缺省构造函数。
2. DoubleArray类。包括一个Double*类型的属性和一个int类型的属性，分别为数组元素和长度。该类至少包括如下方法：
（1）构造函数DoubleArray(int* a, int *b, int n):n为a、b的元素个数，相同位置的a和b的值为一个实数的整数部分和小数部分。如：若a={1,3},b={2,4},n=2，则表示有2个实数：1.2和3.4。
（2）show()方法：显示所有的元素。输出时，数组元素两两之间用1个空格隔开，且前后无多余空格，最后输出一个换行符。
（3）sortArray(bool)：对数组进行排序。当参数值为true时，排序结果为递增序；否则为递减序。
（4）insertAtPos(Double, int)：在第2个参数指定的位置插入第1个参数给定的对象。注意：对于长度为n的数组，合法的插入位置为[0,n]。
（5）deleteADouble(Double)：删除数组中所有与给定参数相等的元素。

实际应用中，要注意：
1. 上述方法的返回值是什么？要根据main函数的调用方法来确定。
2. 仅有上述函数远远不能很好地解决这个问题，需要在Double和DoubleArray中添加其他必要的成员函数。

Input

输入有多行。第一行N>0,表示之后有N个Double类型的对象，之后的N行，每行包括2个用空格隔开的整数，分别是一个Double对象的整数部分和小数部分。
接下来的一行是一个正整数M，表示之后有M行输入，每行输入是两两之间用1个空格隔开的3个整数，前2个整数代表了要插入到当前DoubleArray对象中的一个Double对象，第3个表示插入的位置。

Output

见样例。

Sample Input

391 1389 313123454 112151 2 03 4 55 6 30 0 10 0 4

Sample Output

91.13 89.313 123454.112189.313 91.13 123454.1121123454.1121 91.13 89.3131.2 0.0 123454.1121 91.13 0.0 5.6 89.3131.2 123454.1121 91.13 5.6 89.313

HINT

Append Code

append.cc,

#include <iostream>
using namespace std;
class Double
{
private:
    int first;
    int last;
public:
    Double(int _first = 0,int _last = 0)
    {
        first = _first;
        last = _last;
    }
    void setValue(int x,int y)
    {
        first = x;
        last = y;
    }
    int getFirst()
    {
        return first;
    }
    int getLast()
    {
        return last;
    }
 
    ~Double(){}
};
class DoubleArray
{
private:
    Double* d;
    int len;
public:
    DoubleArray(int * a,int *b,int _len)
    {
        len = _len;
        d = new Double[len];
        for(int i = 0;i < len ;i++)
        {
            d[i].setValue(a[i],b[i]);
        }
 
    }
    void show()
    {
        for(int i = 0;i < len ;i++)
        {
            if(i == 0)
            cout << d[i].getFirst() << "." << d[i].getLast();
            else
                cout << " " << d[i].getFirst() << "." << d[i].getLast();
        }
        cout << "\n";
    }
 
    DoubleArray& sortArray(bool rev)
    {
        Double tmp;
        if(!rev)
        {
            for(int i = 0;i < len ;i++)
            {
                for(int j = 0; j < len - i - 1;j++)
                {
                    if(d[j+1].getFirst() > d[j].getFirst() || (d[j+1].getFirst() == d[j].getFirst() && d[j+1].getLast() > d[j].getLast()))
                    {
                     tmp = d[j+1];
                     d[j+1] = d[j];
                     d[j] = tmp;
                    }
                }
 
            }
        }
        else
        {
            for(int i = 0;i < len ;i++)
            {
                for(int j = 0; j < len - i - 1;j++)
                {
                    if(d[j+1].getFirst() < d[j].getFirst() || (d[j+1].getFirst() == d[j].getFirst() && d[j+1].getLast() < d[j].getLast()))
                    {
                     tmp = d[j+1];
                     d[j+1] = d[j];
                     d[j] = tmp;
                    }
                }
 
            }
        }
        return *this;
    }
    void insertAtPos(Double a, int b)
    {
        if(b < 0 || b >len) return ;
        Double *tmp;
        len++;
        tmp = new Double[len];
        tmp[b].setValue(a.getFirst(),a.getLast());
        for(int i = 0, j = 0;i < len;i++)
        {
            if(i == b) continue;
            tmp[i].setValue(d[j].getFirst(),d[j].getLast());
            j++;
        }
        d = new Double[len];
        for(int i = 0;i < len;i++)
        {
            d[i].setValue(tmp[i].getFirst(),tmp[i].getLast());
        }
        delete []tmp;
    }
    DoubleArray& deleteADouble(Double a)
    {
        for(int i = 0;i < len;i++)
        {
            if(d[i].getFirst() == a.getFirst() && d[i].getLast() == a.getLast())
            {
                for(int j = i; j < len; j++)
                {
                    d[j].setValue(d[j+1].getFirst(),d[j+1].getLast());
                }
                len--;
            }
        }
        return *this;
    }
    ~DoubleArray()
    {
        delete[] d;
    }
};
int main()
{
    Double one, two(10,10);
    int num, i, a, b, c, *iPart, *dPart;
    cin>>num;
    iPart = new int[num];
    dPart = new int[num];
    for (i = 0; i < num; i++)
    {
        cin>>iPart[i]>>dPart[i];
    }
    DoubleArray test(iPart, dPart, num);
    test.show();
    test.sortArray(true).show();
    test.sortArray(false).show();
    cin>>num;
    for (i = 0; i < num; i++)
    {
        cin>>a>>b>>c;
        test.insertAtPos(Double(a, b), c);
    }
    test.show();
    test.deleteADouble(Double()).show();
    delete[] iPart;
    delete[] dPart;
    return 0;
}