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 = ;    //静态成员变量---属于BigInteger这个类型的，不属于他的结构体变量
     static const int WIDTH = ;
     vector<int> s;                        //储存大整数 

     BigInteger(long long num = ) {       //构造函数（带默认值)
         *this = num;
     }
     BigInteger operator = (long long num) {//面对不超过long long的整数
         s.clear();                         //清空本对象的vector容器内容--以免有上一次数据影响
         //将整数里面的数八位八位的 储存到 vector里面去
         do {
             s.push_back(num % BASE);      //假如整数是9位--得到了后面的八位
             num /= BASE;                  //继续得到前面的位数
         } while (num > );
         return *this;                     //返回本对象
     }
     //long long类型不够的情况
     BigInteger operator = (const string& str) { //赋值运算符
         s.clear();
         int x, len = (str.length() - ) / WIDTH + ; //有几个八位一组(多出来的不足8位舍去)
         //从右向左8位8位的储存整数到vector<int>中
         for (int i = ; i < len; i++) {              //按一共有几组八位储存
             int end = str.length() - i*WIDTH;        //i个八位一组--字符串长度 - 几个八位 = 前面剩余的位数
             //取max(0,前面位数 - 8个长度),如果该剩余位数不为0,就取大的
             int start = max(,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 = , g = ; ; i++)
         {
             if (g ==  && 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() - ; i >= ; 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()-; i >= ; i--) {  //从倒数第二位开始输出
         char buf[];
         sprintf(buf, "%08d", x.s[i]);          //将整数当成字符写到buf中输出，不足八位的补零(因为在前面的几组八位中
         //如果不足八位说明在形成整数的过程中最高位为0)
         for (unsigned int j = ; 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 = ;

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