BigInteger类型的解析_超详细解析

/*9876543210987654234522345
214748364723453452323452345
2147483647234523452323452345
181760911432744962345234523
2345234523434656346345634563测试数据*/
#include<iostream>
#include<cstdlib>
#include<cstring>
#include<iterator>
#include<set>
#include<vector>
#include<map>
#include<utility>
#include<algorithm>
using namespace std;

struct BigInteger {
    static const int BASE = 100000000;    //静态成员变量---属于BigInteger这个类型的，不属于他的结构体变量 
    static const int WIDTH = 8;           
    vector<int> s;                        //储存大整数 
    
    BigInteger(long long num = 0) {       //构造函数（带默认值) 
        *this = num;
    }
    BigInteger operator = (long long num) {//面对不超过long long的整数 
        s.clear();                         //清空本对象的vector容器内容--以免有上一次数据影响 
        //将整数里面的数八位八位的 储存到 vector里面去 
        do {
            s.push_back(num % BASE);      //假如整数是9位--得到了后面的八位 
            num /= BASE;                  //继续得到前面的位数 
        } while (num > 0);
        return *this;                     //返回本对象 
    }
    //long long类型不够的情况 
    BigInteger operator = (const string& str) { //赋值运算符 
        s.clear(); 
        int x, len = (str.length() - 1) / WIDTH + 1; //有几个八位一组(多出来的不足8位舍去) 
        //从右向左8位8位的储存整数到vector<int>中 
        for (int i = 0; i < len; i++) {              //按一共有几组八位储存 
            int end = str.length() - i*WIDTH;        //i个八位一组--字符串长度 - 几个八位 = 前面剩余的位数
            //取max(0,前面位数 - 8个长度),如果该剩余位数不为0,就取大的
            int start = max(0,end-WIDTH);
            //成为查找一组数的开始位置，如果取的是end-WIDTH,,那么end-start = WIDTH得到了一个八位,当做查找字符串的长度
            //sscanf()是将字符以某种形式取出存放到相应的类型中(这里是int),substr(start--开始搜寻的位置(包括),
            //end-start----是代表搜寻的长度),c_str()返回一个指针指向字符串相当于一个'\0'结尾的字符数组->用来终止一次 
            //8位的取出到x 
            sscanf(str.substr(start,end-start).c_str(), "%d", &x);
            //要注意在最高位前面的几组8位中，如果他们的第八位为0，那么组成整数的时候就不会有八位，输出时要注意 
            s.push_back(x); //将取出的整数push到vector的底部---大数是从右往左的一点点储存进去 
        }
        return *this;
    }
    //重载 + 运算符
    BigInteger operator + (const BigInteger& b) const
    {
        BigInteger c;
        c.s.clear();                 //清空c类型中vector内的元素 
        for (unsigned int i = 0, g = 0; ; i++)
        {
            if (g == 0 && i >= s.size() && i >= b.s.size())//如果位数已经到了最高位,i大于本对象对象且大于b对象的大小 
                break;                                       //跳出循环 
            int x = g;
            if (i < s.size()) x += s[i];      
            if (i < b.s.size()) x += b.s[i];
            c.s.push_back(x % BASE);          //八位八位的取出取出后(从右向左)
            g = x/BASE;                       //得到最高位向后的位数(一直到从右向左出现的第一次8位前面停止) 
        }
        return c;    
    } 

    BigInteger operator += (const BigInteger &b)
    {
        *this = *this + b;
        return *this;
    }
    

    //比较运算符
    bool operator < (const BigInteger &b) const 
    {
        if (s.size() != b.s.size())
            return s.size() < b.s.size();
        for (int i = s.size() - 1; i >= 0; i--)    //从后往前面比较，因为(低位在vector的前面)注:这样做的前提是两个 
        {                                          //都没有前导0，否则不能比较 
            if (s[i] != b.s[i])    
                return s[i] < b.s[i];
        }
        return false;                              //相等    
    }
    bool operator > (const BigInteger &b) const
    {
        return b < *this;
    }
    bool operator <= (const BigInteger &b) const
    {
        return !(b < *this);                    //相当于返回 本对象 <= b对象    
    }
    bool operator >= (const BigInteger &b) const
    {
        return !(*this < b);    
    }  
    bool operator != (const BigInteger &b) const
    {
        return b < *this || *this < b;
    }
    bool operator == (const BigInteger &b) const
    {
        return !(b < *this) || !(*this <  b);
    }
};

ostream& operator << (ostream &out, const BigInteger &x)
{ 
    out << x.s.back();            //从右向左输出(因为最高位是最后储存进去的)
    //八位八位的写 
    for (int i = x.s.size()-2; i >= 0; i--) {  //从倒数第二位开始输出 
        char buf[20]; 
        sprintf(buf, "%08d", x.s[i]);          //将整数当成字符写到buf中输出，不足八位的补零(因为在前面的几组八位中
        //如果不足八位说明在形成整数的过程中最高位为0) 
        for (unsigned int j = 0; j < strlen(buf); j++)  //输出八位 
            out << buf[j];
    }
    return out; 
} 

istream& operator >> (istream &in, BigInteger &x) {
    string s;
    if (! (in >> s)) 
        return in;
    x = s;              //输入正确的流 
    return in;
} 

struct cmp {
    bool operator () (const BigInteger &a, const BigInteger &b) const {    //升序比较 
        return a < b; 
    }
};

struct cmpL{
    bool operator () (const BigInteger &a, const BigInteger &b) const {    //降序比较 
        return a > b;
    }
};
int main(void)
{
    BigInteger bi, sum1, mus, b2;
    
    set<BigInteger,cmp> s1;
    
    vector<BigInteger> s2;
    
    map<BigInteger,char,cmpL> s3; 
    
    pair<BigInteger,char> s4;
    
    string ss; 
    int i = 1;
    
    /*while (cin >> b2)        //利用了重载 >> 提取运算符 
    {
        mus += b2;    
    }
    cout << mus << endl;*/
    
    while (cin >> ss)
    {
        bi = ss;
        sum1 += bi;
        s1.insert(bi);
        s2.push_back(bi);
        s4.first = bi;
        s4.second = 'a'+i;        //用来检验map里面元素也是可以自动排序的
        i++;
        s3.insert(s4);

    }
    
    for (set<BigInteger,cmp>::iterator it = s1.begin(); it != s1.end(); ++it) //set升序 
        cout << *it << endl;
//    cout << sum1 << endl;
    cout << endl;
    
    sort(s2.begin(),s2.end(),cmpL());       //sort 降序 
    for (vector<BigInteger>::iterator it = s2.begin(); it != s2.end(); ++it)
        cout << *it << endl;
    
    for (map<BigInteger,char,cmpL>::iterator it = s3.begin(); it != s3.end(); ++it) //map降序 
        cout << (*it).second << endl;
    return 0;
}