C++大数精度计算(带小数点)

最新推荐文章于 2024-05-01 12:20:36 发布
最新推荐文章于 2024-05-01 12:20:36 发布
阅读量589 收藏 3
点赞数
文章标签： c/c++
原文链接：http://www.cnblogs.com/acbingo/p/4116206.html
版权

转：

（原出处不可考，若有侵权，请联系我立即删除）

头文件：

// WTNumber.h: interface for the CWTNumber class.
//
//

#if !defined(AFX_WTNUMBER_H__92E62B40_491A_4A75_AB89_FFB160DB2343__INCLUDED_)
#define AFX_WTNUMBER_H__92E62B40_491A_4A75_AB89_FFB160DB2343__INCLUDED_

#if _MSC_VER > 1000
#pragma once
#endif // _MSC_VER > 1000

#define INT_BIT_MAX 255
#define FLOAT_BIT_MAX 255

class CWTNumber  
{
private:
    int intbits;                     /* 整数数位*/
    int floatbits;                   /* 小数有效数位*/
    char infinite;                   /* 无穷大*/
    char sign;                       /* 符号*/
    char intpart[INT_BIT_MAX];       /* 整数部分*/
    char floatpart[FLOAT_BIT_MAX];   /* 小数部分*/
private:
    char* m_sz;
public:
    /* 算术函数指针类型.*/
    typedef void (*PFNCALC)(const CWTNumber&,const CWTNumber&,CWTNumber&);
    CWTNumber();
    CWTNumber(const char* szNum);
    ~CWTNumber();
    /* 转换成字符串*/
    char* ToString();
    void FreeString();
    /* 初始化WTNumber为0.*/
    void InitWTNumberToZero();
    /* 判断需要多少个字符空间存储WTNumber转换的字符串.*/
    int StrLenByWTNumber();
    /* 从字符串转换到WTNumber.*/
    void StrToWTNumber(const char *arr);
    /* 从WTNumber转换到字符串.*/
    void WTNumberToStr(char *szBuf);
    /* 调节数位,删除最高整数位是0的和最低小数位是0的数位.*/
    void AdjustBits();
    /* 移动小数点,delta=0不移动,delta<0往左移动,delta>0往右移动.*/
    void MoveFloatPoint(int delta);
    /* 使无穷大 */
    void MakeInfinite();
    /* 比较2个数大小 */
    int WTCompare(const CWTNumber& n) const;
    /* 判断是否为0 */
    int IsZero() const;
    /* 赋值号重载*/
    CWTNumber& operator=(const CWTNumber& n);

    /* 运算符重载 */
    CWTNumber operator+(const CWTNumber& n);
    CWTNumber operator-(const CWTNumber& n);
    CWTNumber operator*(const CWTNumber& n);
    CWTNumber operator/(const CWTNumber& n);
    CWTNumber& operator+=(const CWTNumber& n);
    CWTNumber& operator-=(const CWTNumber& n);
    CWTNumber& operator*=(const CWTNumber& n);
    CWTNumber& operator/=(const CWTNumber& n);

    bool operator>(const CWTNumber& n);
    bool operator>=(const CWTNumber& n);
    bool operator<(const CWTNumber& n);
    bool operator<=(const CWTNumber& n);
    bool operator==(const CWTNumber& n);
    bool operator!=(const CWTNumber& n);
    /* 加法*/
    static void WTAdd(const CWTNumber& n1,const CWTNumber& n2,CWTNumber& Res);
    /* 乘法*/
    static void WTMultiply(const CWTNumber& n1,const CWTNumber& n2,CWTNumber& Res);
    /* 减法*/
    static void WTSubtract(const CWTNumber& n1,const CWTNumber& n2,CWTNumber& Res);
    /* 除法*/
    static void WTDivide(const CWTNumber& n1,const CWTNumber& n2,CWTNumber& Res);
    /* 根据算术函数返回结果 */
    static char *Result(const char *val1,const char *val2,PFNCALC pfnCalc);
};


#endif // !defined(AFX_WTNUMBER_H__92E62B40_491A_4A75_AB89_FFB160DB2343__INCLUDED_)
View Code

源文件：

// WTNumber.cpp: implementation of the CWTNumber class.
//
//
#include <string.h>
#include <stdlib.h>
#include "WTNumber.h"

//
// Construction/Destruction
//

CWTNumber::CWTNumber()
{
    InitWTNumberToZero();
}
CWTNumber::CWTNumber(const char* szNum)
{
    InitWTNumberToZero();
    StrToWTNumber(szNum);
}
CWTNumber::~CWTNumber()
{
    FreeString();
}
void CWTNumber::FreeString()
{
    if(m_sz) delete []m_sz;
    m_sz=NULL;
}
void CWTNumber::InitWTNumberToZero()
{
    memset(this,0,sizeof(CWTNumber));
}
int CWTNumber::StrLenByWTNumber()
{
    int len = floatbits+intbits+1;
    if(intbits==0) len++;    /* .1 --> 0.1*/
    if(floatbits) len++;    /* '.'*/
    if(sign) len++;        /* '-'*/
    if(infinite) return 11;    /* #INFINITE */
    return len;
}
void CWTNumber::StrToWTNumber(const char *arr)
{
    char *point;
    InitWTNumberToZero();
    if(*arr=='-')    /* 如果是负数*/
    {
        arr++;
        sign=1;
    }
    point=strchr(arr,'.');
    if(point)    /* 找到小数点 */
    {
        int n=intbits=point-arr;    /* 计算出整数数位 */
        while(n)    /* 整数数位不==0则循环 */
        {
            intpart[intbits-n]=arr[n-1]-'0';    /* 将数字低位存在低下标元素*/
            n--;
        }
        while(*++point)
        {
            floatpart[floatbits]=*point-'0';
            floatbits++;
        }
    }
    else    /* 说明没写小数点,全是整数.*/
    {
        int n=intbits=strlen(arr);
        while(n)
        {
            intpart[intbits-n]=arr[n-1]-'0';
            n--;
        }
    }
    AdjustBits();
    /* 处理-0 和0的情况*/
    if(floatbits==0)
    {
        if(intbits==0 || intbits==1&&intpart[0]==0)
            sign=0;
    }
}

void CWTNumber::WTNumberToStr(char *szBuf)
{
    int n=intbits,c;
    memset(szBuf,0,StrLenByWTNumber());
    if(sign)    /* 如果是负数*/
    {
        *szBuf++='-';
    }
    if(infinite) 
    {
        strcat(szBuf,"#INFINITE");
        return;
    }
    while(n)
    {
        szBuf[intbits-n]=intpart[n-1]+'0';
        n--;
    }
    c=0;    /* 是否加了0*/
    if(intbits==0) {
        strcat(szBuf,"0");
        c=1;
    }
    if(floatbits) strcat(szBuf,".");
    n=0;
    while(n<floatbits)
    {
        szBuf[intbits+1+n+c]=floatpart[n]+'0';
        n++;
    }
}
void CWTNumber::AdjustBits()
{
    while(intbits>1&&intpart[intbits-1]==0) intbits--;
    while(floatbits&&floatpart[floatbits-1]==0) floatbits--;
}
void CWTNumber::MoveFloatPoint(int delta)
{
    /* delta<0则往左移动小数点,delta>0则向右移动小数点 */
    if(delta)
    {
        CWTNumber n=*this;
        InitWTNumberToZero();
        sign=n.sign;
        if(delta<0)
        {
            int i;
            delta=-delta;
            for(i=delta;i<n.intbits;i++)
            {
                intpart[intbits++]=n.intpart[i];
            }
            for(i=delta-1;i>=0;i--)
            {
                floatpart[floatbits++]=n.intpart[i];
            }
            for(i=0;i<n.floatbits;i++)
            {
                floatpart[floatbits++]=n.floatpart[i];
            }
        }
        else
        {
            int i;
            for(i=delta;i<n.floatbits;i++)    /* 处理小数部分*/
            {
                floatpart[floatbits++]=n.floatpart[i];
            }
            for(i=delta-1;i>=0;i--)    /* 小数到整数的部分*/
            {
                intpart[intbits++]=n.floatpart[i];
            }
            for(i=0;i<n.intbits;i++)    /* 整数部分*/
            {
                intpart[intbits++]=n.intpart[i];
            }
        }
    }
    AdjustBits();
}
void CWTNumber::MakeInfinite()
{
    infinite=1;
}

int CWTNumber::WTCompare(const CWTNumber& n) const
{
    /* 首先是比较符号*/
    if(sign==0&&n.sign!=0)    /* pn1是正数,pn2是负数*/
        return 1;    /* >*/
    else if(sign!=0&&n.sign==0)    /* pn1是负数,pn2是正数*/
        return -1;    /* <*/
    else    /* 同号状态*/
    {
        /* 比较整数部分*/
        if(intbits>n.intbits)    /* pn1整数数位多*/
            return sign?-1:1;
        else if(intbits<n.intbits)
            return sign?1:-1;
        else    /* 整数数位相同*/
        {
            int i=intbits-1;    /*指到最高位*/
            while(i>=0)
            {
                if(intpart[i]>n.intpart[i])
                    return sign?-1:1;
                else if(intpart[i]<n.intpart[i])
                    return sign?1:-1;
                else i--;
            }
            /* 整数部分相同,比较小数部分*/
            for(i=0;i<floatbits&&i<n.floatbits;)
            {
                if(floatpart[i]>n.floatpart[i])
                    return sign?-1:1;
                else if(floatpart[i]<n.floatpart[i])
                    return sign?1:-1;
                else i++;
            }
            if(i<floatbits) return sign?-1:1;
            if(i<n.floatbits) return sign?1:-1;
            return 0;    /* 相等*/
        }
    }
}
int CWTNumber::IsZero() const
{
    if(floatbits==0&&intbits==0) return 1;
    if(floatbits==0&&intbits==1&&intpart[0]==0) return 1;
    return 0;
}

void CWTNumber::WTAdd(const CWTNumber& n1,const CWTNumber& n2,CWTNumber& Res)
{
    Res.InitWTNumberToZero();
    if(n1.sign^n2.sign)    /*异号*/
    {
        CWTNumber rn2=n2;
        rn2.sign=n1.sign;
        WTSubtract(n1,rn2,Res);
    }
    else    /*同号*/
    {
        int maxfloatbits=n1.floatbits>n2.floatbits?n1.floatbits:n2.floatbits;
        int addbit=0;    /* 进位值*/
        int i,j;
        for(i=maxfloatbits-1;i>=0;i--)
        {
            int value=n1.floatpart[i]+n2.floatpart[i]+addbit;
            addbit=value/10;    /* 看看是否超过10. 设置进位值*/
            Res.floatpart[i]=value%10;
        }
        Res.floatbits=maxfloatbits;
        /* 到此,小数部分计算完毕.*/
        for(j=0;j<n1.intbits||j<n2.intbits;j++)
        {
            int value=n1.intpart[j]+n2.intpart[j]+addbit;
            addbit=value/10;
            Res.intpart[j]=value%10;
            Res.intbits++;
        }
        if(addbit>0)
        {
            Res.intpart[j]=addbit;
            Res.intbits++;
        }
        Res.sign=n1.sign;    /*决定符号*/
        Res.AdjustBits();
    }
}

void CWTNumber::WTMultiply(const CWTNumber& n1,const CWTNumber& n2,CWTNumber& Res)
{
    CWTNumber z1=n1,z2=n2;
    CWTNumber sum;
    int i,j;
    sum.InitWTNumberToZero();
    Res.InitWTNumberToZero();
    z1.MoveFloatPoint(z1.floatbits);
    z2.MoveFloatPoint(z2.floatbits);
    /* 计算z1*z2 */
    for(i=0;i<z2.intbits;i++)
    {
        CWTNumber tmp;    /* 存放临时乘积*/
        int addbit=0;
        tmp.intbits=z1.intbits+i;
        for(j=0;j<z1.intbits;j++)
        {
            int value = z2.intpart[i]*z1.intpart[j]+addbit;
            addbit=value/10;
            tmp.intpart[j+i]=value%10;
        }
        if(addbit)
        {
            tmp.intpart[j+i]=addbit;
            tmp.intbits++;
        }
        WTAdd(sum,tmp,Res);
        sum=Res;
    }
    Res=sum;
    Res.MoveFloatPoint(-(n1.floatbits+n2.floatbits));
    /* 判断符号,异号为负*/
    if(n1.sign^n2.sign) Res.sign=1;
}

void CWTNumber::WTSubtract(const CWTNumber& n1,const CWTNumber& n2,CWTNumber& Res)
{
    Res.InitWTNumberToZero();
    if(n1.sign^n2.sign)    /* 异号情况*/
    {
        CWTNumber rn2=n2;
        rn2.sign=n1.sign;
        WTAdd(n1,rn2,Res);
    }
    else    /* 同号情况*/
    {
        int cmp=n1.WTCompare(n2);
        int swapflag,i,maxfloatbits,subtractbit;
        if(cmp==0) return;    /* 相等就没必要再减了.*/
        swapflag=n1.sign==0?cmp==-1:cmp==1;
        const CWTNumber* pn1=&n1;
        const CWTNumber* pn2=&n2;
        if(swapflag)
        {
            const CWTNumber *t=pn1;
            pn1=pn2;
            pn2=t;
        }
        maxfloatbits=pn1->floatbits>pn2->floatbits?pn1->floatbits:pn2->floatbits;
        subtractbit=0;    /* 退位值*/
        /* 先计算小数部分*/
        for(i=maxfloatbits-1;i>=0;i--)
        {
            if(pn1->floatpart[i]-subtractbit<pn2->floatpart[i])
            {
                int value=pn1->floatpart[i]-pn2->floatpart[i]-subtractbit+10;
                subtractbit=1;
                Res.floatpart[i]=value;
            }
            else
            {
                int value=pn1->floatpart[i]-pn2->floatpart[i]-subtractbit;
                subtractbit=0;
                Res.floatpart[i]=value;
            }
        }
        Res.floatbits=maxfloatbits;
        /* 至此小数部分计算完毕.*/
        for(i=0;i<pn1->intbits||i<pn2->intbits;i++)
        {
            if(pn1->intpart[i]-subtractbit<pn2->intpart[i])
            {
                int value=pn1->intpart[i]-pn2->intpart[i]-subtractbit+10;
                subtractbit=1;
                Res.intpart[i]=value;
            }
            else
            {
                int value=pn1->intpart[i]-pn2->intpart[i]-subtractbit;
                subtractbit=0;
                Res.intpart[i]=value;
            }
            Res.intbits++;
        }
        Res.sign=swapflag?!n1.sign:n1.sign;    /*决定符号*/
        Res.AdjustBits();
    }
}
void CWTNumber::WTDivide(const CWTNumber& n1,const CWTNumber& n2,CWTNumber& Res)
{
    CWTNumber z1=n1,z2=n2;
    int deta=z2.floatbits-z1.floatbits;
    z1.MoveFloatPoint(z1.floatbits);
    z2.MoveFloatPoint(z2.floatbits);
    Res.InitWTNumberToZero();
    if(n1.IsZero()) return ;
    if(n2.IsZero()) {
        Res.sign=n1.sign;
        Res.MakeInfinite();
        return ;
    }
    z1.sign=z2.sign=0;                /*统一符号,便于比较大小*/ 
    while(z1.intbits!=z2.intbits) {    /*确保数位相等,这步耗费很多时间*/
        if(z1.intbits<z2.intbits) {
            z1.MoveFloatPoint(1);
            deta--;
        } else {
            z2.MoveFloatPoint(1);
            deta++;
        }
    }
    while(Res.floatbits<(INT_BIT_MAX/2)) {
        int cmp=z1.WTCompare(z2);
        int n=10;
        CWTNumber mulres,subres;
        if(cmp==-1) {      /*z1<z2*/
            z1.MoveFloatPoint(1);
            Res.floatpart[Res.floatbits++]=0;
            continue;
        } else if(cmp==0) { /*z1==z2*/
            Res.floatpart[Res.floatbits++]=1;
            break;
        }
        do {    /*找商*/
            CWTNumber tmp;
            tmp.intpart[0]=--n;
            tmp.intbits=1;
            WTMultiply(z2,tmp,mulres);
        } while((cmp=mulres.WTCompare(z1))==1);
        Res.floatpart[Res.floatbits++]=n;
        if(cmp==0) break;
        WTSubtract(z1,mulres,subres);
        subres.MoveFloatPoint(1);
        z1=subres;
    }
    Res.MoveFloatPoint(1);
    Res.MoveFloatPoint(deta);
    /* 判断符号,异号为负*/
    if(n1.sign^n2.sign) Res.sign=1;
}
char *CWTNumber::Result(const char *val1,const char *val2,PFNCALC pfnCalc)
{
    CWTNumber n1,n2,res;
    n1.StrToWTNumber(val1);
    n2.StrToWTNumber(val2);
    pfnCalc(n1,n2,res);
    return res.ToString();
}

char* CWTNumber::ToString()
{
    FreeString();
    m_sz=new char[StrLenByWTNumber()];
    WTNumberToStr(m_sz);
    return m_sz;
}

CWTNumber& CWTNumber::operator=(const CWTNumber& n)
{
    if(this!=&n) {
        FreeString();
        memcpy(this,&n,sizeof(CWTNumber));
        if(n.m_sz)
        {
            m_sz=strdup(n.m_sz);
        }
    }
    return *this;
}


CWTNumber CWTNumber::operator+(const CWTNumber& n)
{
    CWTNumber res;
    CWTNumber::WTAdd(*this,n,res);
    return res;
}
CWTNumber CWTNumber::operator-(const CWTNumber& n)
{
    CWTNumber res;
    CWTNumber::WTSubtract(*this,n,res);
    return res;
}
CWTNumber CWTNumber::operator*(const CWTNumber& n)
{
    CWTNumber res;
    CWTNumber::WTMultiply(*this,n,res);
    return res;
}
CWTNumber CWTNumber::operator/(const CWTNumber& n)
{
    CWTNumber res;
    CWTNumber::WTDivide(*this,n,res);
    return res;
}
CWTNumber& CWTNumber::operator+=(const CWTNumber& n)
{
    CWTNumber n1=*this,n2=n;
    CWTNumber::WTAdd(n1,n2,*this);
    return *this;
}
CWTNumber& CWTNumber::operator-=(const CWTNumber& n)
{
    CWTNumber n1=*this,n2=n;
    CWTNumber::WTSubtract(n1,n2,*this);
    return *this;
}
CWTNumber& CWTNumber::operator*=(const CWTNumber& n)
{
    CWTNumber n1=*this,n2=n;
    CWTNumber::WTMultiply(n1,n2,*this);
    return *this;
}
CWTNumber& CWTNumber::operator/=(const CWTNumber& n)
{
    CWTNumber n1=*this,n2=n;
    CWTNumber::WTDivide(n1,n2,*this);
    return *this;
}
bool CWTNumber::operator>(const CWTNumber& n)
{
    return WTCompare(n)==1;
}
bool CWTNumber::operator>=(const CWTNumber& n)
{
    return WTCompare(n)!=-1;
}
bool CWTNumber::operator<(const CWTNumber& n)
{
    return WTCompare(n)==-1;
}
bool CWTNumber::operator<=(const CWTNumber& n)
{
    return WTCompare(n)!=1;
}
bool CWTNumber::operator==(const CWTNumber& n)
{
    return WTCompare(n)==0;
}
bool CWTNumber::operator!=(const CWTNumber& n)
{
    return WTCompare(n)!=0;
}
View Code

使用演示:

#include <stdio.h>
#include "WTNumber.h"

int main()
{
    char sz1[256]="";
    char sz2[256]="";
    puts("请输入两个数字:");
    while(scanf("%s%s",sz1,sz2)!=-1)
    {
        CWTNumber n1(sz1),n2(sz2);
        printf("两数相加结果:\n%s\n",(n1+n2).ToString());
        printf("两数相减结果:\n%s\n",(n1-n2).ToString());
        printf("两数相乘结果:\n%s\n",(n1*n2).ToString());
        printf("两数相除结果:\n%s\n",(n1/n2).ToString());
        puts("请输入两个数字:");
    }
    return 0;
}
View Code

 

转载于:https://www.cnblogs.com/acbingo/p/4116206.html

weixin_30401605
关注
  • 0
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
大数（含小数）的四则运算
08-11
大数四则运算的实现
表达式求值 C++（可计算小数）
11-15
表达式求值，使用链栈实现，包括欢迎模块，表达式输入，计算，检验模块，可计算小数。
关于c++ 小数的精度处理
最新发布
2301_81582286的博客
05-01 169
eg-%.3lf 为double类型保留3位小数，第三位小数会四舍五入%.4f 为float类型保留四位小数，最后一位小数会四舍五入下面为例子输出为111.445。
大数四则运算（带小数及正负号），附PI计算
10-12
本程序用VC++6.0平台运行通过，对PI求值运算算到了350位，并可进一步运算，但效率一般
大数运算c++
07-31
大数运算代码；写了大数运算基本的加减乘除、矩阵求逆运算及矩阵加减乘除。采用字符数组的方式实现，可以通过宏来设定所需要的精度，包括小数点后的位数。
C++大数四则运算（带符号及小数）
10-11
大数四则运算还小数及正负符号，可实现2000位以内的四则运算，大于2000需改数组,经初步测试通过，传上交流下希望能给点意见以便不断改进
C++中对于浮点数的精确计算（求小数的最大公约数、最小公倍数、负小数除法）
yifei_maple的博客
09-13 669
对负浮点数进行精确计算，避免了c++中精度不高的问题，实现了浮点数的最大公约数、最小公倍数的计算
C++实现string类型的大数相加（带小数）
aowuqiang9874的博客
09-05 617
近日，做了一道阿里给的大数相加的编程题。题目大意如下： 输入两个string类型的数，如12.223 11，判断输入字符串是否合法。合法则输出true以及相加结果（true 23.223），非法则输出false """"。 期间几经修改，在判断合法方面排除了如.212以及122.这种错误（出现除数字以及.以外的错误亦已排除）。 主要的思路是将小数与整数部分进行分离，分别相加。由于...
C++中大数的四则运算以及求模，包含自定义小数位数的高精度除法
mmd_xx的博客
03-24 602
起因 在做算法题时经常会处理一些较大的超过c++long long类型的数据，而在网上寻找到的大数运算代码良莠不齐。遂自己敲了一份，代码目前有许多没有优化的地方，希望大家可以指出其中的不足之处，一起进步。 代码实现及注释 #include <bits/stdc++.h> using namespace std; class Operation { public: Operation...
c++ 计算器 能实现带括号的小数计算
01-18
//介绍程序 void introduction(){ cout<<"这是一个计算机程序，支持：+，-，*，/,(,)的浮点数运算"<<endl; cout<<"请不要以+，-，*，/开头，请注意括号的匹配"<<endl; cout<<"请不要输入不必要的括号"<<endl; } 如输入1+3*1.2+（2+2.2)= 就会给计算结果8.8
C语言高精度浮点计算代码
04-05
【问题描述】 计算 k *∑(x^i), －m ≤ i ≤ n，精确到小数点后14位（最后要求四舍五入）。 【输入形式】 从文件sigma.in中顺序读入4个由空格分隔的正整数k、x、m、n。(1≤ k、x、m、n ≤ 100)。 【输出形式】 将结果写到标准输出，其中小数占14位，不足部分补零，最后输出一个回车。(输入数据保证输出结果小于2^53。) 【输入样例】 1 10 5 5 【输出样例】 111111.11111000000000
一个计算圆周率达到小数点后任意精度的程序
10-08
C++中的浮点运算和大数库（如GMP或MPFR）可以处理高精度计算。同时，为了提高效率，可能需要使用优化的技术，如多线程或者并行计算。 在提供的压缩包文件中，有三个文件：APTEST.EXE可能是实际运行的程序，CONFIG....
GaoJingDu.rar_除法_高精度除法
09-24
高精度计算在密码学（如RSA加密）、科学计算、金融计算（精确到小数点后多位）、游戏开发（模拟大数值）等领域都有广泛的应用。 总结，"GaoJingDu.rar"资源中的“GaoJingDu.ppt”可能是讲解高精度计算的演示文稿，...
使用C++中string实现任意长度的正小数、整数之间加减法方法实例
08-30
而在C++中，使用标准库的string类型，使得大数问题的计算更加实用（没有最大值的限制），更加灵活（输入更加简洁方便），更加简单（可以方便的处理小数之间的运算）。 二、算法原理 简单描述：看如下大整数的加法...
c语言中int下小数求余大数,使用C++中string实现任意长度的正小数、整数之间加减法方法实例...
weixin_28965963的博客
05-17 865
一、概述C/C++中的int类型能表示的范围是-2E31－2E31–1。unsigned类型能表示的范围是0－2E32–1，即 0－4294967295。所以，int和unsigned类型变量，都不能保存超过10位的整数。有时我们需要参与运算的数，可能会远远不止10 位，例如，可能需要保留小数点后面100位(比如求π的值)，那么，即便使用能表示很大数值范围的double变量，但是由于double变...
[C++实现]高精度算法
m0_71229255的博客
02-10 2118
​ 在一般的科学计算中，会经常算到小数点后几百位或者更多，当然也可能是几千亿几百亿的大数字。一般这类数字我们统称为高精度数，高精度算法是用计算机对于超大数据的一种模拟加、减、乘、除、乘方、阶乘、开方等运算。 对于一个很大的数字N >= 10^ 100，很显然这样的数字无法在计算机中正常存储。于是， 我们想到了办法，将这个数字拆开，拆成一位一位的或者是四位四位的存储到一个数组中，用一个数组去表示一个数字。这样这个数字就被称谓是高精度数。 对于高精度数，也要像平常数一样做加减乘除以及乘方的运算，于是就有了高精度
C++高精度算法—大数加大数，大数乘以小数
fk961859482的专栏
12-09 3875
一次偶然的机会，看到百度面试题中出现了很多关于处理大数据的处理题目，也称作高精度题目，另外在ACM竞赛中也偶尔会碰到。我们知道在C语言或C++语言中，通常受机器字长的限制，我们会碰到如果某个整数的范围超过一个范围就没法运算。这时我们只能先用字符串读进去，然后再将字符型的“数”转换成数值的“数”，再模拟手算，一位一位相加，最后得到结果。         具体请看下面的例子： #include
带小数的高精度加减法运算（C++）
2302_79795489的博客
02-29 864
带小数的高精度加减法运算（C++）
C++ 实现高精度计算
"这份资源是关于C++实现高精度计算的教程，主要讲解如何处理大整数的存储、输入输出、运算以及相关的编程技巧。" 在C++编程中，内置的整数类型如short、int、long long等都有其存储上限，无法满足需要极高精度的...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值