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;
}