小白书--高精度、字符串处理总结

首先要说明的是ACM题目中涉及的基本是初级高精度，直接模拟手算一般不会超时（也可用java），关于高精度的研究还有很多，介绍一个Huge cal库：http://www.emath.ac.cn/hugecalc/

关于字符串，主要增加一些ａｃｍ入门知识。

以分知识点的形式给出：

1：scanf %c 有其独特的优越性，易于控制。当然getline(cin,str)也是不错的选择，要用到string

2：sprintf（）函数，字符串格式化命令，把格式化数据写入某个字符串缓冲区，是个变参函数。（用途：把已经输入的数字转化成字符串形式的快捷方式）

3 : 用scanf获取整行字符串（包括空格）scanf("%[^\n]",str); scanf中的参数：%[ ],意义是限定读入这个集合中的字符，['0','1'....'9']意思是输入数字，如果遇到非数字就停止了，如果集合的第一个字符是"^",　这说明读取不在"^"　后面集合的字符,既遇到"^"　后面集合的字符便停止.注意此时读入的字符串是可以含有空格的。要注意的是，读取一行后要加getchar()以读取缓冲区中的换行符，否则'\n'将出现在下一行的读取中。 借鉴自：http://wangqingyun84.blog.163.com/blog/static/79083617201262691716249/

4：关于gets(str)函数在vim中warning的问题，方法一：直接无视提交或CB中运行两次；方法二：用fgets(str,len,stdin);，len为所定义的str数组长度即可。

5：同样的有fputs(str,stdout);

下面给出C++高精度模板，采集自小白书（有改动），也借鉴了http://blog.csdn.net/mbxc816/article/details/7192461博客。

这里只是分模块的给出，毕竟各自模块的思想都要烂熟于心。

6：

C/C++ string库（string.h）提供了几个字符串查找函数，如下：

 

memchr	在指定内存里定位给定字符
strchr	在指定字符串里定位给定字符
strcspn	返回在字符串str1里找到字符串str2里的任意一个字符之前已查找的字符数量
strrchr	在字符串里定位给定字符最后一次出现的位置
strpbrk	在字符串str1里定位字符串str2里任意一个首次出现的字符
strspn	返回字符串str1从开始字符到第一个不在str2中的字符个数
strstr	在字符串str1中定位字符串str2首次出现的位置

 详细：http://blog.csdn.net/isgray/article/details/6853700

 

1：bign结构体定义

 

const int maxn = 100000;

struct bign{
    int len,s[maxn + 5];

    //初始化与赋值
    bign(){
        memset(s,0,sizeof(s));
        len = 1;//因为0的存在
    }
};

 

 

 

2：bign成员函数 -- 初始化及赋值

 

//初始化与赋值
    bign(){
        memset(s,0,sizeof(s));
        len = 1;//因为0的存在
    }

    bign operator = (const char *num){
        memset(s,0,sizeof(s));
        len = strlen(num);
        for(int i = 0; i < len; ++i)
            s[i] = num[len - i - 1] - '0';//倒序转化成数字
        return *this;
    }

    bign operator = (int num){
        memset(s,0,sizeof(s));
        char ts[maxn + 5];
        sprintf(ts,"%d",num);
        *this = ts;
        return *this;
    }

    bign(int num){
        *this = num;
    }

    bign(const char *num){
        *this = num;
    }
    //bign的str型转化
    string str() const{
        string res = "";
        for(int i = len - 1; i >= 0; --i)
            res +=  (char)(s[i] + '0');
        if(res == "")
            res = "0";
        return res;
    }

 

 

 

3：bign成员函数 -- 四则运算符重载

 //运算符重载
    //高精度加
    bign operator + (const bign & b) const{
        bign sum;
        sum.len = 0;
        for(int i = 0, g = 0; g || i < max(len,b.len); ++i){
            int x = g;//x:暂存和,g:进位
            if(i < len) x += s[i];
            if(i < b.len) x += b.s[i];
            sum.s[sum.len++] = x % 10;
            g = x / 10;
        }
        return sum;
    }

    //高精度减
    bign operator - (const bign & b) const{
        bign dif;
        int maxlen = (len > b.len) ? len : b.len;
        for(int i = 0; i < maxlen; ++i){
            dif.s[i] += s[i] - b.s[i];
            if(dif.s[i] < 0){
                dif.s[i] += 10;
                --dif.s[i + 1];
            }
        }
        dif.len = maxlen;
        while(dif.s[dif.len - 1] == 0 && dif.len > 1)
            --dif.len;
        return dif;
    }

    //高精度乘,实际上加和乘对进位的处理有所不同
    bign operator * (const bign &b) const{
        bign pro;
        pro.len = 0;
        for(int i = 0; i < len; ++i){
            for(int j = 0; j < b.len; ++j){
                pro.s[i + j] += (s[i] * b.s[j]);
                pro.s[i + j + 1] += pro.s[i + j] / 10;
                pro.s[i + j] %= 10;
            }
        }
        pro.len = len + b.len + 1;//这里注意pro.len初始值可能是题目数字范围两倍
        while(pro.s[pro.len - 1] == 0 && pro.len > 1)
            --pro.len;//最后一位不管是不是0都不能让len - 1
        if(pro.s[pro.len])
            ++pro.len;//这句有待商讨
        return pro;
    }

    //高精度乘以低精度
    bign operator * (const int num) const{
        int c = 0,t;
        bign pro;
        for(int i = 0; i < len; ++i){
            t = s[i] * num + c;
            pro.s[i] = t % 10;
            c = t / 10;
        }
        pro.len = len;
        while(c != 0){
            pro.s[pro.len++] = c % 10;
            c /= 10;
        }
        return pro;
    }

    //高精度除,模拟连减
    bign operator / (const bign & b) const{
        bign quo,f;
        for(int i = len - 1; i >= 0; --i){
            f = f * 10;
            f.s[0] = s[i];
            while(f >= b){
                f = f - b;
                ++quo.s[i];
            }
        }
        quo.len = len;
        while(quo.s[quo.len - 1] == 0 && quo.len > 1)
            --quo.len;
        return quo;
    }
    
    //高精度取模
    bign operator % (const bign & b) const{
        bign rem;
        for(int i = len - 1; i >= 0; --i){
            rem = rem * 10;
            rem.s[0] = s[i];
            while(rem >= b){
                rem = rem - b;
            }
        }
        rem.len = len;
        while(rem.s[rem.len - 1] == 0 && rem.len > 1){
            --rem.len;
        }
        return rem;
    }

4：bign成员函数 -- 比较运算符重载及流运算符重载

//比较运算符
    bool operator < (const bign & b) const{
        if(len != b.len) return len < b.len;
        for(int i = len - 1; i >= 0; --i)//从高位开始比较
            if(s[i] != b.s[i])
                return s[i] < b.s[i];
        //如果 本身 == b
        return false;
    }

    bool operator > (const bign &b) const{
        return b < *this;//代表 本身 > b
    }

    bool operator <= (const bign &b) const{
        return !(b < *this);//带表 !(本身 > b)
    }

    bool operator >= (const bign &b) const{
        return !(*this < b);
    }

    bool operator != (const bign &b) const{
        return *this < b || b < *this;
    }

    bool operator == (const bign &b) const{
        return !(*this < b) && !(b < *this);
    }

    friend istream & operator >> (istream & in,bign & x);
    friend ostream & operator << (ostream & out,const bign & x);

//写在bign外部的友元函数
istream & operator >> (istream & in,bign & x){
    string ts;
    in >> ts;
    x = ts.c_str();
    return in;
}

ostream & operator << (ostream & out,const bign & x){
    out << x.str();
    return out;
} 

 

最后附上总结版：

#include <cstdio>
#include <string>
#include <cstring>
#include <iostream>
using namespace std;

const int maxn = 100000;

struct bign{
    int len,s[maxn + 5];

    //初始化与赋值
    bign(){
        memset(s,0,sizeof(s));
        len = 1;//因为0的存在
    }

    bign operator = (const char *num){
        memset(s,0,sizeof(s));
        len = strlen(num);
        for(int i = 0; i < len; ++i)
            s[i] = num[len - i - 1] - '0';//倒序转化成数字
        return *this;
    }

    bign operator = (int num){
        memset(s,0,sizeof(s));
        char ts[maxn + 5];
        sprintf(ts,"%d",num);
        *this = ts;
        return *this;
    }

    bign(int num){
        *this = num;
    }

    bign(const char *num){
        *this = num;
    }
    //bign的str型转化
    string str() const{
        string res = "";
        for(int i = len - 1; i >= 0; --i)
            res +=  (char)(s[i] + '0');
        if(res == "")
            res = "0";
        return res;
    }
    //运算符重载
    //高精度加
    bign operator + (const bign & b) const{
        bign sum;
        sum.len = 0;
        for(int i = 0, g = 0; g || i < max(len,b.len); ++i){
            int x = g;//x:暂存和,g:进位
            if(i < len) x += s[i];
            if(i < b.len) x += b.s[i];
            sum.s[sum.len++] = x % 10;
            g = x / 10;
        }
        return sum;
    }

    //高精度减
    bign operator - (const bign & b) const{
        bign dif;
        int maxlen = (len > b.len) ? len : b.len;
        for(int i = 0; i < maxlen; ++i){
            dif.s[i] += s[i] - b.s[i];
            if(dif.s[i] < 0){
                dif.s[i] += 10;
                --dif.s[i + 1];
            }
        }
        dif.len = maxlen;
        while(dif.s[dif.len - 1] == 0 && dif.len > 1)
            --dif.len;
        return dif;
    }

    //高精度乘,实际上加和乘对进位的处理有所不同
    bign operator * (const bign &b) const{
        bign pro;
        pro.len = 0;
        for(int i = 0; i < len; ++i){
            for(int j = 0; j < b.len; ++j){
                pro.s[i + j] += (s[i] * b.s[j]);
                pro.s[i + j + 1] += pro.s[i + j] / 10;
                pro.s[i + j] %= 10;
            }
        }
        pro.len = len + b.len + 1;//这里注意pro.len初始值可能是题目数字范围两倍
        while(pro.s[pro.len - 1] == 0 && pro.len > 1)
            --pro.len;//最后一位不管是不是0都不能让len - 1
        if(pro.s[pro.len])
            ++pro.len;//这句有待商讨
        return pro;
    }

    //高精度乘以低精度
    bign operator * (const int num) const{
        int c = 0,t;
        bign pro;
        for(int i = 0; i < len; ++i){
            t = s[i] * num + c;
            pro.s[i] = t % 10;
            c = t / 10;
        }
        pro.len = len;
        while(c != 0){
            pro.s[pro.len++] = c % 10;
            c /= 10;
        }
        return pro;
    }

    //高精度除,模拟连减
    bign operator / (const bign & b) const{
        bign quo,f;
        for(int i = len - 1; i >= 0; --i){
            f = f * 10;
            f.s[0] = s[i];
            while(f >= b){
                f = f - b;
                ++quo.s[i];
            }
        }
        quo.len = len;
        while(quo.s[quo.len - 1] == 0 && quo.len > 1)
            --quo.len;
        return quo;
    }

    //高精度取模
    bign operator % (const bign & b) const{
        bign rem;
        for(int i = len - 1; i >= 0; --i){
            rem = rem * 10;
            rem.s[0] = s[i];
            while(rem >= b){
                rem = rem - b;
            }
        }
        rem.len = len;
        while(rem.s[rem.len - 1] == 0 && rem.len > 1){
            --rem.len;
        }
        return rem;
    }
    //比较运算符
    bool operator < (const bign & b) const{
        if(len != b.len) return len < b.len;
        for(int i = len - 1; i >= 0; --i)//从高位开始比较
            if(s[i] != b.s[i])
                return s[i] < b.s[i];
        //如果 本身 == b
        return false;
    }

    bool operator > (const bign &b) const{
        return b < *this;//代表 本身 > b
    }

    bool operator <= (const bign &b) const{
        return !(b < *this);//带表 !(本身 > b)
    }

    bool operator >= (const bign &b) const{
        return !(*this < b);
    }

    bool operator != (const bign &b) const{
        return *this < b || b < *this;
    }

    bool operator == (const bign &b) const{
        return !(*this < b) && !(b < *this);
    }

    friend istream & operator >> (istream & in,bign & x){
        string ts;
        in >> ts;
        x = ts.c_str();
        return in;
    }
    friend ostream & operator << (ostream & out,const bign & x){
        out << x.str();
        return out;
    }
};

int main(){
    char st1[maxn + 5],st2[maxn + 5];
    bign n1,n2;
    
    printf("加：");
    scanf("%s%s",st1,st2);
    n1 = st1;
    n2 = st2;
    cout << n1 + n2 << endl;

    printf("减：");
    scanf("%s%s",st1,st2);
    n1 = st1;
    n2 = st2;
    cout << n1 - n2 << endl;

    printf("乘1：");
    scanf("%s%s",st1,st2);
    n1 = st1;
    n2 = st2;
    cout << n1 * n2 << endl;

    printf("乘2：");
    scanf("%s%s",st1,st2);
    n1 = st1;
    n2 = st2;
    cout << n1 * n2 << endl;

    printf("除：");
    scanf("%s%s",st1,st2);
    n1 = st1;
    n2 = st2;
    cout << n1 / n2 << endl;
    
    printf("模：");
    scanf("%s%s",st1,st2);
    n1 = st1;
    n2 = st2;
    cout << n1 % n2 << endl;

    return 0;
}