数字字符串四则运算

最新推荐文章于 2024-04-08 16:47:11 发布
最新推荐文章于 2024-04-08 16:47:11 发布
阅读量846 收藏
点赞数
分类专栏： VC and C++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/sdhongjun/article/details/50534182
版权
string版本
#include <stdio.h>
#include <string>

#define ASSERT(b) \
    printf("%s : %s\n", #b, b ? "OK" : "Fail");

using namespace std;

class CNumber
{
    enum AlignZeroFlag
    {
        ALIGN_ZERO_LEFT, //对齐时左侧填充0
        ALIGN_ZERO_RIGHT //对齐时右侧填充0
    };

public:
    //数字字符顺序 123456 => CNumber m_strNum[0] = '1'

    CNumber() : m_strNum("0")
    {

    }

    CNumber(const char *num) : m_strNum(num)
    {
        FormtNumStr(m_strNum);
    }

    CNumber(const int num)
    {
        Num2Str(num, m_strNum);
    }

    CNumber(const CNumber &other)
    {
        m_strNum = other.m_strNum;
    }

    CNumber& operator=(const CNumber &rhs)
    {
        if (this != &rhs)
        {
            m_strNum = rhs.m_strNum;
        }

        return *this;
    }

    bool IsNegative() const
    {
        return IsNegative(m_strNum);
    }

    bool IsZero() const
    {
        return m_strNum[0] == '0';
    }

    //abs(CNumber)
    CNumber abs(const CNumber &other)
    {
        CNumber num(other);

        if (num.IsNegative()) num *= -1;

        return num;
    }

    //++CNumber
    CNumber& operator++()
    {
        return operator+=(1);
    }

    //CNumber++
    CNumber operator++(const int)
    {
        CNumber numRet = *this;

        operator+=(1);

        return numRet;
    }

    //--CNumber
    CNumber& operator--()
    {
        return operator-=(1);
    }

    //CNumber--
    CNumber operator--(const int)
    {
        CNumber numRet = *this;

        operator-=(1);

        return numRet;
    }

    //CNumber > CNumber
    bool operator>(const CNumber &rhs) const
    {
        return gt(m_strNum, rhs.m_strNum);  
    }

    //CNumber < CNumber
    bool operator<(const CNumber &rhs) const
    {
        return !(operator>(rhs));
    }

    //CNumber == CNumber
    bool operator==(const CNumber &rhs) const
    {       
        return eq(m_strNum, rhs.m_strNum);
    }

    //CNumber + CNumber
    friend CNumber operator+(const CNumber &lhs, const CNumber &rhs);

    //CNumber += CNumber;
    CNumber& operator+=(const CNumber &rhs)
    {
        m_strNum = Add(m_strNum, rhs.m_strNum);

        return *this;
    }

    //CNumber - CNumber
    friend CNumber operator-(const CNumber &lhs, const CNumber &rhs);

    //CNumber -= CNumber;
    CNumber& operator-=(const CNumber &rhs)
    {
        if (*this == rhs)
        {
            m_strNum = "0";
            return *this;
        }

        m_strNum = Subtract(m_strNum, rhs.m_strNum);

        return *this;
    }

    //CNumber * CNumber
    friend CNumber operator*(const CNumber &lhs, const CNumber &rhs);

    //CNumber *= CNumber;
    CNumber& operator*=(const CNumber &rhs)
    {
        m_strNum = Multiply(m_strNum, rhs.m_strNum);

        return *this;
    }

    //CNumber / CNumber
    friend CNumber operator/(const CNumber &lhs, const CNumber &rhs);

    //CNumber /= CNumber;
    CNumber& operator/=(const CNumber &rhs)
    {
        string strNumRemainder;

        m_strNum = Divide(m_strNum, rhs.m_strNum, strNumRemainder);

        return *this;
    }

    //CNumber % CNumber
    friend CNumber operator%(const CNumber &lhs, const CNumber &rhs);
    //CNumber %= CNumber;
    CNumber& operator%=(const CNumber &rhs)
    {
        Divide(m_strNum, rhs.m_strNum, m_strNum); 
        return *this;
    }


public:
    //数字转换为字符串
    static void Num2Str(int n, string &strNum)
    {
        if (n == 0)
        {
            strNum = "0";
            return;
        }

        char    cSign = 0;
        strNum.clear();

        if (n < 0)
        {
            cSign = '-';
            n = -n;
        }

        while (n > 0)
        {
            strNum.insert(strNum.begin(), char((n%10) + '0'));

            n /= 10;
        }

        if (cSign)
        {
            strNum.insert(strNum.begin(), cSign);
        }
    }


    //负数判定
    static bool IsNegative(const string &num)
    {
        if (0 == num.size()) return false;
        return (num[0] == '-');
    }

    //零判定
    static bool IsZero(const string &num)
    {
        if (0 == num.size()) return true;
        return num[0] == '0';
    }

    //去除数字前面的'+'号及'0'字符
    static void FormtNumStr(string &strNum)
    {
        switch (strNum.size())
        {
        case 0:
            //"" => "0"
            strNum = "0";
            return;
        case 1:
            {
                //"-" or "+" => "0"
                if (('-' == strNum[0]) || ('+' == strNum[0]))
                {
                    strNum = "0";
                    return;
                }
            }
            break;
        }

        //+5 => 5
        if ('+' == strNum[0])
        {
            strNum.erase(0, 1);
        }

        if ('-' == strNum[0])
        {
            //-0005 => -5
            while (strNum.size() > 2)
            {
                if ('0' != strNum[1]) break;
                strNum.erase(1, 1);
            }
        }
        else
        {
            //0005 => 5
            while (strNum.size() > 1)
            {
                if ('0' != strNum[0]) break;
                strNum.erase(0, 1);
            }
        }
    }

    //对齐数字
    static void AlignNumStr(string &strNum1, string &strNum2, AlignZeroFlag flag)
    {
        FormtNumStr(strNum1);
        FormtNumStr(strNum2);

        size_t nNumOffset1  = strNum1[0] == '-' ? 1 : 0;
        size_t nNumOffset2  = strNum2[0] == '-' ? 1 : 0;
        size_t nNum1Length  = strNum1.size() - nNumOffset1;
        size_t nNum2Length  = strNum2.size() - nNumOffset2;
        size_t nFixCnt      = 0;
        size_t nFixOffset   = 0;
        string *pStrNumToFix= NULL;

        if (nNum1Length == nNum2Length) return;

        if (nNum1Length > nNum2Length)
        {
            nFixCnt         = nNum1Length - nNum2Length;
            nFixOffset      = nNumOffset2;
            pStrNumToFix    = &strNum2;
        }
        else
        {
            nFixCnt         = nNum2Length - nNum1Length;
            nFixOffset      = nNumOffset1;
            pStrNumToFix    = &strNum1;
        }

        string &strFixNum   = *pStrNumToFix;
        if (ALIGN_ZERO_LEFT == flag)
        {
            strFixNum.insert(nFixOffset, nFixCnt, '0');
        }
        else
        {
            strFixNum.insert(strFixNum.size(), nFixCnt, '0');
        }
    }

    //取绝对值
    static string abs(const string &num)
    {
        string strRes(num);

        FormtNumStr(strRes);
        if (IsNegative(strRes))
        {
            strRes.erase(0, 1);
        }

        return strRes;
    }

    //相等
    static bool eq(const string &strNum1, const string &strNum2)
    {
        string num1(strNum1), num2(strNum2);

        AlignNumStr(num1, num2, ALIGN_ZERO_LEFT);

        //符号不同
        if (IsNegative(num1) != IsNegative(num2)) return false;

        //相同符号
        for (size_t i = 0; i < num1.size(); ++i)
        {
            if (num1[i] != num2[i]) return false;
        }

        return true;
    }

    //大于
    static bool gt(const string &strNum1, const string &strNum2)
    {
        bool bSameSign = IsNegative(strNum1) == IsNegative(strNum2);

        if (!bSameSign)
        {
            if (IsNegative(strNum1)) return false;

            return true;
        }

        string num1(strNum1), num2(strNum2);

        AlignNumStr(num1, num2, ALIGN_ZERO_LEFT);

        for (size_t i = 0; i < num1.size(); ++i)
        {
            if (num1[i] == num2[i]) continue;

            if (num1[i] > num2[i])
            {
                return IsNegative(num1) ? false : true;
            }
            else
            {
                return IsNegative(num1) ? true : false;
            }
        }

        return false;
    }

    //大于等于
    static bool gte(const string &strNum1, const string &strNum2)
    {
        return gt(strNum1, strNum2) || eq(strNum1, strNum1);
    }

    //小于
    static bool lt(const string &strNum1, const string &strNum2)
    {
        if (eq(strNum1, strNum2)) return false;

        return !gt(strNum1, strNum2);
    }

    //小于等于
    static bool lte(const string &strNum1, const string &strNum2)
    {
        return lt(strNum1, strNum2) || eq(strNum1, strNum2);
    }

    //加
    static string Add(const string &strNum1, const string &strNum2)
    {
        string  strSum, num1(strNum1), num2(strNum2);

        AlignNumStr(num1, num2, ALIGN_ZERO_LEFT);

        if (IsNegative(num1) != IsNegative(num2))
        {
            if (IsNegative(num1))
            {
                //-10 + 5
                num1.erase(0, 1);
                return Subtract(num2, num1);
            }

            //10 + (-5)
            num2.erase(0, 1);
            return Subtract(num1, num2);
        }

        //5 + 10
        //-5 + (-10)
        size_t  nNumOffset  = num1[0] == '-' ? 1 : 0;
        int     nSum(0), nCA(0);

        strSum.resize(num1.size());
        if (nNumOffset) strSum[0] = '-';//设置负号标志
        for (size_t i = num1.size(), idx; i > nNumOffset; --i)
        {
            idx     = i - 1;
            nSum    = (num1[idx] - '0') + (num2[idx] - '0') + nCA;
            nCA     = nSum / 10;
            nSum    %= 10;

            strSum[idx] = char(nSum + '0');
        }

        if (nCA)
        {
            strSum.insert(nNumOffset, 1, char(nCA + '0'));
        }

        return strSum;
    }

    //减
    static string Subtract(const string &strNum1, const string &strNum2)
    {
        string  strResult("0"), num1(strNum1), num2(strNum2);
        string  *pLHS(NULL), *pRHS(NULL);
        char    cSign(0);

        AlignNumStr(num1, num2, ALIGN_ZERO_LEFT);

        if (eq(num1, num2)) return strResult;

        bool bSameSign = IsNegative(num1) == IsNegative(num2);

        if (!bSameSign)
        {
            if (IsNegative(num1))
            {
                //-10 - 5
                num2.insert(0, 1, '-');             
            }
            else
            {
                //10 - (-5)
                num2.erase(0, 1);
            }

            return Add(num1, num2);         
        }

        pLHS = &num1;
        pRHS = &num2;
        if (IsNegative(num1))
        {
            if (gt(num1, num2))
            {
                //-5 - (-10)
                pLHS = &num2;
                pRHS = &num1;
            }
            else
            {
                //-10 - (-5)
                cSign = '-';
            }

            //去除负号标志
            num1.erase(0, 1);
            num2.erase(0, 1);
        }
        else
        {
            //10 - 5
            if (gt(num1, num2))
            {
                ;
            }
            else
            {
                //5 - 10
                pLHS = &num2;
                pRHS = &num1;
                cSign = '-';
            }
        }

        string &strLHS = *pLHS;
        string &strRHS = *pRHS;

        strResult.resize(strLHS.size());
        for (size_t i = strLHS.size(), idx; i > 0; --i)
        {
            idx = i - 1;
            if (strLHS[idx] >= strRHS[idx])
            {
                strLHS[idx] = strLHS[idx] - strRHS[idx] + '0';
                continue;
            }

            strLHS[idx] = 10 + (strLHS[idx] - strRHS[idx]) + '0';
            for (size_t j = idx; j > 0; --j)
            {
                if (strLHS[j - 1] != '0')
                {
                    --strLHS[j - 1];
                    break;
                }

                strLHS[j - 1] = '9';
            }
        }

        if (cSign)
        {
            strLHS.insert(0, 1, cSign);
        }

        strResult = strLHS;
        return strResult;
    }

    //乘
    static string Multiply(const string &strNum1, const string &strNum2)
    {
        string strResult("0"), num1(strNum1), num2(strNum2);

        FormtNumStr(num1);
        FormtNumStr(num2);

        if (IsZero(num1) || IsZero(num2)) return strResult;

        if (eq(num1, "-1"))
        {
            if (IsNegative(num2))
            {
                num2.erase(0, 1);
            }
            else
            {
                num2.insert(0, 1, '-');
            }

            return num2;
        }

        if (eq(num2, "-1"))
        {
            if (IsNegative(num1))
            {
                num1.erase(0, 1);
            }
            else
            {
                num1.insert(0, 1, '-');
            }

            return num1;
        }

        bool    bSameSign = IsNegative(num1) == IsNegative(num2);       
        char    cSign = bSameSign ? 0 : '-';        
        string  *pLHS(NULL), *pRHS(NULL);

        if (IsNegative(num1)) num1.erase(0, 1);
        if (IsNegative(num2)) num2.erase(0, 1);

        pLHS = &num1;
        pRHS = &num2;

        //多位数作为被乘数
        if (num1.size() < num2.size())
        {
            pLHS = &num2;
            pRHS = &num1;
        }

        string  &strLHS = *pLHS;
        string  &strRHS = *pRHS;
        string  strTmp;
        int     n1, n2;
        int     nMul(0);
        int     nCA(0);

        strResult.clear();
        for (size_t i = strRHS.size(), idx = 0; i > 0; --i, ++idx)
        {
            n1 = strRHS[i - 1] - '0';
            strTmp.clear();
            strTmp.resize(strLHS.size());
            for (size_t j = strLHS.size(); j > 0; --j)
            {
                n2      = strLHS[j - 1] - '0';
                nMul    = n1 * n2 + nCA;
                nCA     = nMul / 10;
                nMul    %= 10;

                strTmp[j - 1] = nMul + '0';             
            }

            if (nCA)
            {
                strTmp.insert(0, 1, char(nCA + '0'));
            }

            //x10^n
            strTmp.insert(strTmp.size(), idx, '0');
            strResult = Add(strResult, strTmp);
        }

        if (cSign)
        {
            strResult.insert(0, 1, cSign);
        }

        return strResult;
    }

    //乘
    static string Multiply(const string &strNum1, int n)
    {
        string strNum2;
        Num2Str(n, strNum2);

        return Multiply(strNum1, strNum2);
    }

    //除
    static string Divide(const string &strNum1, const string &strNum2, string &numRemainder)
    {
        string strResult("0"), num1(strNum1), num2(strNum2), strMul, strSub;
        numRemainder = "0";

        FormtNumStr(num1);
        FormtNumStr(num2);

        if (IsZero(strNum2)) return strResult;

        bool bSameSign = IsNegative(num1) == IsNegative(num2);
        char cSign = bSameSign ? 0 : '-';

        if (lt(abs(num1), abs(num2)))
        {
            numRemainder = num1;
            return strResult;
        }

        if (eq(abs(num1), abs(num2)))
        {
            strResult = "1";
            if (cSign) strResult.insert(0, 1, cSign);
            return strResult;
        }

        if (IsNegative(num1)) num1.erase(0, 1);
        if (IsNegative(num2)) num2.erase(0, 1);

        //商位数       
        size_t num1Length   = num1.size();
        size_t num2Length   = num2.size();
        size_t nLoopCnt     = num1Length - num2Length + 1;

        strResult.resize(nLoopCnt);
        numRemainder = num1.substr(0, num2.size());
        for (size_t i = 0; i < nLoopCnt; ++i)
        {
            if (gte(numRemainder, num2))
            {
                int n = (numRemainder[0] - '0')/(num2[0] - '0' + 1);
                while (1)
                {
                    strMul = Multiply(num2, n);
                    strSub = Subtract(numRemainder, strMul);

                    if (lt(strSub, num2))
                    {
                        break;
                    }

                    ++n;
                }
                strResult[i] = char(n + '0');
                numRemainder = strSub;
            }
            else
            {
                strResult[i] = '0';
            }

            numRemainder += num1[num2Length + i];
            FormtNumStr(numRemainder);
        }

        if (cSign) strResult.insert(0, 1, cSign);
        return strResult;
    }

private:
    string m_strNum;
};

CNumber operator+(const CNumber &lhs, const CNumber &rhs)
{
    CNumber numRet(lhs);

    numRet += rhs;
    return numRet;
}

CNumber operator-(const CNumber &lhs, const CNumber &rhs)
{
    CNumber numRet(lhs);

    numRet -= rhs;
    return numRet;
}

CNumber operator*(const CNumber &lhs, const CNumber &rhs)
{
    CNumber numRet(lhs);

    numRet *= rhs;
    return numRet;
}

CNumber operator/(const CNumber &lhs, const CNumber &rhs)
{
    CNumber numRet(lhs);

    numRet /= rhs;
    return numRet;
}

CNumber operator%(const CNumber &lhs, const CNumber &rhs)
{
    CNumber numRet(lhs);

    numRet %= rhs;
    return numRet;
}

void calc1(const CNumber &num1, const CNumber &num2, CNumber &numSum, CNumber &numSub, CNumber &numMul, CNumber &numDiv)
{
    numSum = num1 + num2;
    numSub = num1 - num2;
    numMul = num1 * num2;
    numDiv = num1 / num2;
}

int main()
{
    CNumber num1, num2, numSum, numSub, numMul, numDiv;

    if (0) {
        ASSERT(CNumber::lt("-99", "-90"));
        ASSERT(CNumber::lte("-99", "-99"));
        ASSERT(CNumber::lte("-99", "-100") == false);
        ASSERT(CNumber::lt("-99", "-100") == false);
        ASSERT(CNumber::lt("-9", "10"));
        ASSERT(CNumber::lt("5", "10"));
        ASSERT(CNumber::lte("10", "10"));
    }

    if (0) {
        num1 = "99";
        num2 = "-100";
        calc1(num1, num2, numSum, numSub, numMul, numDiv);

        ASSERT(numSum == "-1");
        ASSERT(numSub == "199");
        ASSERT(numMul == "-9900");
        ASSERT(numDiv == "0");
    }

    if (1) {
        string strRemainder, sTmp;
        int n = 19 % 8;
        CNumber::Divide("19", "8", strRemainder);
        CNumber::Num2Str(n, sTmp);
        ASSERT(sTmp == "3");
    }


    if (0) {
        calc1(num2, num1, numSum, numSub, numMul, numDiv);

        ASSERT(numSum == "-1");
        ASSERT(numSub == "-199");
    }

    if (0) {
        num1 = "-99";
        num2 = "10";
        calc1(num1, num2, numSum, numSub, numMul, numDiv);

        ASSERT(numSum == "-89");
        ASSERT(numSub == "-109");
        ASSERT(numMul == "-990");
        ASSERT(numDiv == "-9");
    }

    if (0) {
        num1 = "100";
        num2 = "100";
        calc1(num1, num2, numSum, numSub, numMul, numDiv);

        ASSERT(numSum == "200");
        ASSERT(numSub == "0");
        ASSERT(numMul == "10000");
        ASSERT(numDiv == "1");
    }

    if (0) {
        num1 = "-100";
        num2 = "100";
        calc1(num1, num2, numSum, numSub, numMul, numDiv);

        ASSERT(numSum == "0");
        ASSERT(numSub == "-200");
        ASSERT(numMul == "-10000");
        ASSERT(numDiv == "-1");
    }

    if (1) {
        num1 = "55";
        num2 = "100";
        calc1(num1, num2, numSum, numSub, numMul, numDiv);

        ASSERT(numSum == "155");
        ASSERT(numSub == "-45");
        ASSERT(numMul == "5500");
        ASSERT(numDiv == "0");
    }

    return 0;
}
vector版本
#include <stdio.h>
#include <string>
#include <vector>

#define ASSERT(b) \
    printf("%s : %s\n", #b, b ? "OK" : "Fail");

using namespace std;

class CNumber
{
    typedef vector<char> vecNum;
    enum AlignZeroFlag
    {
        ALIGN_ZERO_LEFT, //对齐时左侧填充0
        ALIGN_ZERO_RIGHT //对齐时右侧填充0
    };

public:
    //数字字符顺序 123456 => CNumber m_vNum[0] = 1

    CNumber() : m_bNegatave(false)
    {
        m_vNum.push_back(0);
    }

    CNumber(const char *num)
    {
        SetNum(num);
    }

    CNumber(const int num)
    {
        SetNum(num);
    }

    CNumber(const CNumber &other)
    {
        m_bNegatave = other.m_bNegatave;
        m_vNum      = other.m_vNum;
    }

    CNumber& operator=(const CNumber &rhs)
    {
        if (this != &rhs)
        {
            m_bNegatave = rhs.m_bNegatave;
            m_vNum      = rhs.m_vNum;
        }

        return *this;
    }

    bool IsNegative() const
    {
        return m_bNegatave;
    }

    bool IsZero() const
    {
        return m_vNum[0] == 0;
    }

    //abs(CNumber)
    CNumber abs(const CNumber &other)
    {
        CNumber num(other);

        if (num.IsNegative()) num.m_bNegatave = false;

        return num;
    }

    //++CNumber
    CNumber& operator++()
    {
        return operator+=(1);
    }

    //CNumber++
    CNumber operator++(const int)
    {
        CNumber numRet = *this;

        operator+=(1);

        return numRet;
    }

    //--CNumber
    CNumber& operator--()
    {
        return operator-=(1);
    }

    //CNumber--
    CNumber operator--(const int)
    {
        CNumber numRet = *this;

        operator-=(1);

        return numRet;
    }

    //CNumber > CNumber
    bool operator>(const CNumber &rhs) const
    {
        if (IsZero() && rhs.IsZero()) return false;

        if (IsNegative() != rhs.IsNegative())
        {
            //不同符号
            if (IsNegative()) return false;

            return true;
        }

        //相同符号

        if (m_vNum.size() != rhs.m_vNum.size())
        {
            //不同长度
            if (m_vNum.size() > rhs.m_vNum.size())
            {
                return IsNegative() ? false : true;
            }

            return IsNegative() ? true : false;
        }

        for (size_t i = 0; i < m_vNum.size(); ++i)
        {
            if (m_vNum[i] == rhs.m_vNum[i]) continue;

            if (m_vNum[i] > rhs.m_vNum[i])
            {
                //-9 < -8 || 9 > 8
                return IsNegative() ? false : true;
            }

            //-8 > -9 || 8 < 9
            return IsNegative() ? true : false;
        }

        return false;
    }

    //CNumber >= CNumber
    bool operator>=(const CNumber &rhs) const
    {
        return operator>(rhs) || operator==(rhs);
    }

    //CNumber < CNumber
    bool operator<(const CNumber &rhs) const
    {
        if (operator==(rhs)) return false;

        return !(operator>(rhs));
    }

    //CNumber <= CNumber
    bool operator<=(const CNumber &rhs) const
    {
        return operator<(rhs) || operator==(rhs);
    }

    //CNumber == CNumber
    bool operator==(const CNumber &rhs) const
    {       
        if (IsNegative() != rhs.IsNegative()) return false;

        return eq(m_vNum, rhs.m_vNum);
    }

    //CNumber + CNumber
    friend CNumber operator+(const CNumber &lhs, const CNumber &rhs);

    //CNumber += CNumber;
    CNumber& operator+=(const CNumber &rhs)
    {
        bool    bSameSign = IsNegative() == rhs.IsNegative();
        CNumber numRHS(rhs);

        if (!bSameSign)
        {
            //不同符号
            if (IsNegative())
            {
                //-m + n
                m_bNegatave = false;
                numRHS.operator -= (*this);

                *this = numRHS;
            }
            else
            {
                //m + -n
                numRHS.m_bNegatave = false;
                operator -=(numRHS);
            }

            return *this;
        }

        //相同符号

        int     nCA(0), nSum(0);

        AlignNum(m_vNum, numRHS.m_vNum, ALIGN_ZERO_LEFT);

        for (size_t i = m_vNum.size(), idx; i > 0; --i)
        {
            idx     = i - 1;
            nSum    = nCA + m_vNum[idx] + numRHS.m_vNum[idx];
            nCA     = nSum / 10;
            nSum    %= 10;

            m_vNum[idx] = nSum;
        }

        if (nCA) m_vNum.insert(m_vNum.begin(), 1, (char)nCA);

        return *this;
    }

    //CNumber - CNumber
    friend CNumber operator-(const CNumber &lhs, const CNumber &rhs);

    //CNumber -= CNumber;
    CNumber& operator-=(const CNumber &rhs)
    {
        if (*this == rhs)
        {
            SetNum((int)0);
            return *this;
        }

        bool    bSameSign = IsNegative() == rhs.IsNegative();
        CNumber numRHS(rhs);

        if (!bSameSign)
        {
            if (IsNegative())
            {
                //-m - n
                numRHS.m_bNegatave = true;
                operator += (numRHS);
            }
            else
            {
                //m - (-n)
                numRHS.m_bNegatave = false;
                operator += (numRHS);
            }

            return *this;
        }

        AlignNum(m_vNum, numRHS.m_vNum, ALIGN_ZERO_LEFT);

        int n1, n2, nSub;
        m_bNegatave = *this < numRHS;

        if (m_bNegatave)
        {
            m_vNum.swap(numRHS.m_vNum);
        }

        for (size_t i = m_vNum.size(), idx; i > 0; --i)
        {
            idx = i - 1;
            n1  = m_vNum[idx];
            n2  = numRHS.m_vNum[idx];
            nSub= n1 - n2;

            if (nSub < 0)
            {
                nSub += 10;//转换为正数

                for (size_t j = idx; j > 0; --j)
                {
                    if (m_vNum[j - 1] != 0)
                    {
                        --m_vNum[j - 1];
                        break;
                    }

                    m_vNum[j - 1] = 9;
                }
            }

            m_vNum[idx] = (char)nSub;
        }

        FormatNum(m_vNum);

        return *this;
    }

    //CNumber * CNumber
    friend CNumber operator*(const CNumber &lhs, const CNumber &rhs);

    //CNumber *= CNumber;
    CNumber& operator*=(const CNumber &rhs)
    {
        if (IsZero() || rhs.IsZero())
        {
            SetNum((int)0);
            return *this;
        }

        bool    bSameSign = IsNegative() == rhs.IsNegative();
        CNumber numRHS(rhs), numMul, numTemp;
        int     n1, n2, nMul, nCA(0);

        m_bNegatave = !bSameSign;//设置符号

        if (m_vNum.size() < numRHS.m_vNum.size())
        {
            m_vNum.swap(numRHS.m_vNum);
        }

        numMul.SetNum((int)0);
        for (size_t i = numRHS.m_vNum.size(), nMul10(0); i > 0; --i, ++nMul10)
        {
            n1 = numRHS.m_vNum[i-1];

            numTemp.SetNum((int)0);
            numTemp.m_vNum.resize(m_vNum.size());
            for (size_t j = m_vNum.size(); j > 0; --j)
            {
                n2      = m_vNum[j - 1];
                nMul    = n1 * n2 + nCA;
                nCA     = nMul / 10;
                nMul    %= 10;

                numTemp.m_vNum[j - 1] = (char)nMul;
            }
            if (nCA) numTemp.m_vNum.insert(numTemp.m_vNum.begin(), 1, (char)nCA);

            if (nMul10)
            {
                //x 10^n
                numTemp.m_vNum.insert(numTemp.m_vNum.end(), nMul10, 0);
            }

            numMul += numTemp;
        }

        m_vNum.swap(numMul.m_vNum);
        return *this;
    }

    //CNumber / CNumber
    friend CNumber operator/(const CNumber &lhs, const CNumber &rhs);

    //CNumber /= CNumber;
    CNumber& operator/=(const CNumber &rhs)
    {
        CNumber remainder;
        *this = Divide(*this, rhs, remainder);

        return *this;
    }

    //CNumber % CNumber
    friend CNumber operator%(const CNumber &lhs, const CNumber &rhs);
    //CNumber %= CNumber;
    CNumber& operator%=(const CNumber &rhs)
    {
        Divide(*this, rhs, *this); 
        return *this;
    }

    static CNumber Divide(const CNumber &lhs, const CNumber &rhs, CNumber &remainder)
    {
        CNumber numRet, numMul;
        bool    bSameSign   = lhs.IsNegative() == rhs.IsNegative();

        numRet.m_bNegatave  = !bSameSign;//设置符号

        if (eq(lhs.m_vNum, rhs.m_vNum))
        {
            remainder.SetNum((int)0);
            numRet.SetNum(1);
            numRet.m_bNegatave = !bSameSign;
            return numRet;
        }

        if (lt(lhs.m_vNum, rhs.m_vNum))
        {
            numRet.SetNum((int)0);
            remainder = lhs;
            return numRet;
        }

        size_t num1Length   = lhs.m_vNum.size();
        size_t num2Length   = rhs.m_vNum.size();
        //商位数  
        size_t nLoopCnt     = num1Length - num2Length + 1;

        numRet.m_vNum.resize(nLoopCnt);
        remainder.m_vNum.clear();
        remainder.m_vNum.resize(rhs.m_vNum.size());
        for (size_t i = 0; i < rhs.m_vNum.size(); ++i)
        {
            remainder.m_vNum[i] = lhs.m_vNum[i];
        }

        //全部设置为正数
        for (size_t i = 0; i < nLoopCnt; ++i)
        {
            if (i != 0) remainder.m_vNum.push_back(lhs.m_vNum[num2Length + i]);

            if (gte(remainder.m_vNum, rhs.m_vNum))
            {
                int n = 0;
                if (remainder.m_vNum[i] < rhs.m_vNum[i])
                {
                    //5/9
                    if (remainder.m_vNum.size() == rhs.m_vNum.size())
                    {
                        numRet.m_vNum[i] = 0;
                        continue;
                    }

                    n = (remainder.m_vNum[0]*10 + remainder.m_vNum[1]) / rhs.m_vNum[0];
                }
                else
                {
                    n = remainder.m_vNum[0] / rhs.m_vNum[0];
                }

                while (1)
                {
                    numMul = rhs * n;
                    if (lt(numMul.m_vNum ,remainder.m_vNum))
                    {
                        remainder -= numMul;
                        break;
                    }

                    --n;
                }

                numRet.m_vNum[i] = (char)n;
                FormatNum(remainder.m_vNum);
            }
            else
            {
                numRet.m_vNum[i] = 0;
            }
        }

        FormatNum(numRet.m_vNum);

        return numRet;
    }


private:
    static bool gt(const vecNum &num1, const vecNum &num2)
    {
        if (num1.size() > num2.size()) return true;

        if (num1.size() < num2.size()) return false;

        for (size_t i = 0; i < num1.size(); ++i)
        {
            if (num1[i] == num2[i]) continue;

            if (num1[i] > num2[i]) return true;
            return false;
        }

        return false;
    }

    static bool eq(const vecNum &num1, const vecNum &num2)
    {
        if (num1.size() != num2.size()) return false;

        for (size_t i = 0; i < num1.size(); ++i)
        {
            if (num1[i] != num2[i]) return false;
        }

        return true;
    }

    static bool lt(const vecNum &num1, const vecNum &num2)
    {
        if (eq(num1, num2)) return false;

        return !gt(num1, num2);
    }

    static bool gte(const vecNum &num1, const vecNum &num2)
    {
        return gt(num1, num2) || eq(num1, num2);
    }

    static void FormatNum(vecNum &num)
    {
        if (num.size() == 0)
        {
            num.push_back(0);
            return;
        }

        while (num.size() > 1)
        {
            if (num[0] != 0) break;

            num.erase(num.begin());
        }
    }

private:
    void SetNum(const char *szNum)
    {
        size_t nLen(0);

        m_bNegatave = false;
        if ((NULL == szNum) || ((nLen = strlen(szNum)) == 0))
        {

            m_vNum.push_back(0);
            return;
        }

        char c(0);
        for (size_t i = 0; i < nLen; ++i)
        {
            c = szNum[i];

            if (i == 0)
            {
                if (c == '+') continue;
                if (c == '-')
                {
                    m_bNegatave = true;
                    continue;
                }
            }

            if ((c >= '0') && (c <= '9'))
            {
                m_vNum.push_back(c - '0');
            }
        }

        if (m_vNum.empty()) m_vNum.push_back(0);
    }

    void SetNum(int num)
    {
        m_bNegatave = (num < 0);

        if (m_bNegatave) num *= -1;

        m_vNum.clear();
        while (num > 0)
        {
            m_vNum.insert(m_vNum.begin(), 1, num % 10);
            num /= 10;
        }

        if (m_vNum.empty()) m_vNum.push_back(0);
    }

    void AlignNum(vecNum &num1, vecNum &num2, AlignZeroFlag flag)
    {
        size_t  nNumLenth1  = num1.size();
        size_t  nNumLenth2  = num2.size();
        vecNum  *pAlignNum  = &num2;
        size_t  nAlignCnt   = nNumLenth1 - nNumLenth2;

        if (nNumLenth1 == nNumLenth2) return;

        if (nNumLenth1 < nNumLenth2)
        {
            pAlignNum   = &num1;
            nAlignCnt   = nNumLenth2 - nNumLenth1;
        }

        if (ALIGN_ZERO_LEFT == flag)
        {
            pAlignNum->insert(pAlignNum->begin(), nAlignCnt, 0);
        }
        else
        {
            pAlignNum->insert(pAlignNum->end(), nAlignCnt, 0);
        }
    }

private:
    bool            m_bNegatave;
    vector<char>    m_vNum;
};

CNumber operator+(const CNumber &lhs, const CNumber &rhs)
{
    CNumber numRet(lhs);

    numRet += rhs;
    return numRet;
}

CNumber operator-(const CNumber &lhs, const CNumber &rhs)
{
    CNumber numRet(lhs);

    numRet -= rhs;
    return numRet;
}

CNumber operator*(const CNumber &lhs, const CNumber &rhs)
{
    CNumber numRet(lhs);

    numRet *= rhs;
    return numRet;
}

CNumber operator/(const CNumber &lhs, const CNumber &rhs)
{
    CNumber numRet(lhs);

    numRet /= rhs;
    return numRet;
}

CNumber operator%(const CNumber &lhs, const CNumber &rhs)
{
    CNumber numRet(lhs);

    numRet %= rhs;
    return numRet;
}

void calc1(const CNumber &num1, const CNumber &num2, CNumber &numSum, CNumber &numSub, CNumber &numMul, CNumber &numDiv)
{
    numSum = num1 + num2;
    numSub = num1 - num2;
    numMul = num1 * num2;
    numDiv = num1 / num2;
}

int main()
{
    CNumber num1, num2, numSum, numSub, numMul, numDiv;

    if (1) {
        num1 = "99";
        num2 = "-100";
        calc1(num1, num2, numSum, numSub, numMul, numDiv);

        ASSERT(numSum == "-1");
        ASSERT(numSub == "199");
        ASSERT(numMul == "-9900");
        ASSERT(numDiv == "0");
    }

    if (1) {
        num1 = "-99";
        num2 = "10";
        calc1(num1, num2, numSum, numSub, numMul, numDiv);

        ASSERT(numSum == "-89");
        ASSERT(numSub == "-109");
        ASSERT(numMul == "-990");
        ASSERT(numDiv == "-9");
    }

    if (1) {
        num1 = "100";
        num2 = "100";
        calc1(num1, num2, numSum, numSub, numMul, numDiv);

        ASSERT(numSum == "200");
        ASSERT(numSub == "0");
        ASSERT(numMul == "10000");
        ASSERT(numDiv == "1");
    }

    if (1) {
        num1 = "-100";
        num2 = "100";
        calc1(num1, num2, numSum, numSub, numMul, numDiv);

        ASSERT(numSum == "0");
        ASSERT(numSub == "-200");
        ASSERT(numMul == "-10000");
        ASSERT(numDiv == "-1");
    }

    if (1) {
        num1 = "55";
        num2 = "100";
        calc1(num1, num2, numSum, numSub, numMul, numDiv);

        ASSERT(numSum == "155");
        ASSERT(numSub == "-45");
        ASSERT(numMul == "5500");
        ASSERT(numDiv == "0");
    }

    return 0;
}
sdhongjun
关注
专栏目录
解析字符串换算为四则运算
03-13
解析字符串换算为四则运算公式根据优先级进行数字运算
数字字符串的四则运算（加减乘除）
WFL_Tesla的博客
08-25 5423
由于平时在做题时会用到数字字符串模拟大数加减乘除，但是网上的大部分代码都只是针对大整数而言，无法对小数和负数进行运算。所以特地写了一个类，包括了大数相加、大数相减、大数相乘、大整数相除。 大数相加 (可以是整数、小数、负数) 大数相减(可以是整数、小数、负数) 大数相乘(可以是整数、小数、负数) 大整数相除(只能是正整数，...
数字字符串运算
why why why?妖妖灵吗
12-11 572
文章目录500. Keyboard Row872. Leaf-Similar Trees893. Groups of Special-Equivalent Strings 500. Keyboard Row Given a List of words, return the words that can be typed using letters of alphabet on only one ...
字符串类型的数字的加减乘除运算
qq_44357109的博客
03-03 7043
除法 string Divide(string str,int x){ int remainder=0; for(int i=0;i<str.size();i++){ int current=str[i]-'0'+remainder*10; str[i]=current/x+'0'; remainder=current%x; } int pos=0; while(str[pos]=='0') pos++; return str.substr(pos); } 乘法 string
字符串和数字运算问题
是略不是咯的博客
07-20 814
字符串和数字运算问题 如果在运算过程中，一开始就发现有字符串类型，会把后面的类型转换成字符串类型，这时候再进行+操作，会把数值拼接起来而不是相加的操作 但是如果字符串类型在中间或者最后出现，那么前面的数值还是按照原来的相加操作，后面的数值会进行拼接操作 int a=10; int b=20; System.out.println(""+a+b); System.out.println(a+b+""); System.out.println(a+b+""+a+b); 运算结果： 1020 30 301020
字符串型的数字相加减_字符串乘法
weixin_39552768的博客
11-23 1123
读完本文，你可以去力扣拿下如下题目：43.字符串相乘-----------对于比较小的数字，做运算可以直接使用编程语言提供的运算符，但是如果相乘的两个因数非常大，语言提供的数据类型可能就会溢出。一种替代方案就是，运算数以字符串的形式输入，然后模仿我们小学学习的乘法算术过程计算出结果，并且也用字符串表示。需要注意的是，num1 和 num2 可以非常长，所以不可以把他们直接转成整型然后运算，唯一的思...
四则运算解析器（字符串）
10-30
四则运算解析器是一种计算机程序，它能够接收包含加、减、乘、除等四则运算符的字符串表达式，并将其转化为可执行的计算过程。这个解析器通常用于解决基础的数学问题，对于编程初学者来说，理解并实现这样一个解析器...
字符串的四则运算demo
11-08
在IT领域，字符串的四则运算通常涉及到编程中的表达式解析和计算。在这个"字符串的四则运算demo"中，开发者使用了一种高级的技术——反射机制，结合编译原理，来处理字符串形式的数学公式并得出计算结果。下面将详细...
c# 字符串转四则运算
10-16
在C#编程中，处理字符串并将其转换为可执行的四则运算是一项常见的任务，尤其在解析用户输入或处理表达式时。以下是一篇详细解释如何实现这一功能的文章。 首先，我们要理解四则运算的基本概念，包括加法（+）、...
python数值运算 四则运算
12-21
在这个示例中，我们首先检查输入字符串的分割部分是否为三个，然后分别将两个数字转换为浮点数，并根据运算符执行相应的四则运算。这样，我们可以更好地控制可能出现的错误，并给出适当的反馈。 总的来说，Python中...
Java 字符运算，与数字的运算
qq_39579087的博客
04-16 5563
字符与字符进行加减运算 此时会先将字符转换为ASCII码，将二者ASCII码值相加。 char i = '3' + '0'; int j = '3' + '0'; i的值为c，j的值为99，因为字符c的ASCII码为99 字符与数字进行加减运算 会将字符转换为ASCII码，然后和数字相加。 char i = 3 + '0'; int j = 3 + '0'; i的值为3，因为字符0的ASCII码为48，加3后为51，而51正好是字符3的ascii码；那么很显然j的值就为51 字符与数字之间的转换 如果有
JavaScript中字符串与数字间的运算
Potry Code的博客
08-09 5546
JavaScript中字符串与数字间的运算分三种情况 第一种：字符串+数字 "12"+34="1234"; 带双引号的为字符串，如果和一个数字相加，那么它的结果为字符串。除非两个数字都不带双引号，则才可以实现两个数字的相加。 12+34=46; 第二种：第一个（无论是字串还是数字）前面有符号： +"12"+34=46; 因为"12"前面有+号（或者叫连字符），+号前面没有别的东西了，所以就判...
Python编写“四则运算”
最新发布
le_u_6的博客
04-08 495
1_以下定义的四则运算的单词在代码中作为“变量名”，只要和结果输出的名字一致就行，所以改成其他字母也行。3_输出时可直接打印变量，但打印字符串拼接时要注意都得是字符串格式 如：”...” + str()2_保证具体运算中的符号+ - * / 输入正确，其结果一般就符合想要的计算。仅此记录下编写过程中的小细节（其实是忘了被除数不可为0...... ^_O）
python对字符串实现四则运算
掉下个小石头
09-12 7007
华电北风吹 天津大学认知计算与应用重点实验室 日期：2015/9/12根据小学学的四则元算法则，对输入的字符串实现比较大小，加法，减法，乘法，除法和求余等运算。__author__ = 'zhengyi' class StringArithmetic: # Class Condition: x,y are both non-negative # Compare x and y, i
数字字符串做运算
sych888的专栏
12-19 1418
对字符串 1,2,3,4,5 做算术运算 SQL> select dbms_aw.eval_number(replace('1,2,3,4,5',',','+')) from dual; DBMS_AW.EVAL_NUMBER(REPLACE('1,2,3,4,5',',','+')) -------------------------------------------
字符串 字符 数字的加法运算
zhengzhongz的博客
01-04 1953
实现数字型字符串的加法运算
weixin_42909191的博客
08-07 2117
实现数字型字符串的加法运算 如输入字符串num1=”1234”, num2=”234”,输出”1468”;num1=”1234”, num2=”-234”,输出”1000”;可实现高精度运算 代码实现 #include &amp;lt;stdio.h&amp;gt; #include &amp;lt;stdlib.h&amp;gt; #include &amp;lt;string.h&amp;gt; void reverseStr(ch...
字符串算法大整理！你能想到的都能找到（补全中）
热门推荐
UranusITS的博客
07-16 1万+
字符串算法大整理！你能想到的都能找到（吧）。 2018.7.16 Chengdu 今天学习了字符串相关的一些算法，种类挺多的，特来整理一波。 字符串哈希(Hash) 简介 原理 哈希查找 字符串哈希 哈希的弊端 &amp;amp;amp;amp;amp;amp;amp; 如何卡哈希 字符串哈希(Hash) 简介 哈希( HashHashHash )是一种神奇的查找算法，广泛运用于计算机领域，它的...
linux C实现字符串四则运算计算
05-16
以下是一个简单的实现，可以计算两个数字之间的加、减、乘、除运算，支持整数和浮点数： ```c #include <stdio.h> #include <stdlib.h> #include <string.h> #include <ctype.h> #define MAX_LENGTH 100 /* 定义运算符的优先级 */ typedef enum { ADD, SUB, MUL, DIV } Operator; /* 判断字符是否为运算符 */ int is_operator(char c) { return c == '+' || c == '-' || c == '*' || c == '/'; } /* 获取运算符的优先级 */ int get_priority(Operator op) { switch (op) { case ADD: case SUB: return 1; case MUL: case DIV: return 2; } } /* 计算两数之间的四则运算 */ double calculate(double a, double b, Operator op) { switch (op) { case ADD: return a + b; case SUB: return a - b; case MUL: return a * b; case DIV: return a / b; } } /* 计算表达式的值 */ double evaluate(char *expr) { char *ptr = expr; Operator op_stack[MAX_LENGTH]; double num_stack[MAX_LENGTH]; int op_top = -1, num_top = -1; while (*ptr) { /* 如果是数字，将其转换为实数并入栈 */ if (isdigit(*ptr) || *ptr == '.') { double num = atof(ptr); num_stack[++num_top] = num; /* 跳过数字 */ while (isdigit(*ptr) || *ptr == '.') { ptr++; } } /* 如果是运算符 */ else if (is_operator(*ptr)) { Operator op; switch (*ptr) { case '+': op = ADD; break; case '-': op = SUB; break; case '*': op = MUL; break; case '/': op = DIV; break; } /* 将栈中优先级高于等于该运算符的运算符出栈，并计算结果入栈 */ while (op_top >= 0 && get_priority(op_stack[op_top]) >= get_priority(op)) { Operator top_op = op_stack[op_top--]; double b = num_stack[num_top--]; double a = num_stack[num_top--]; num_stack[++num_top] = calculate(a, b, top_op); } /* 将该运算符入栈 */ op_stack[++op_top] = op; ptr++; } /* 如果是空格，跳过 */ else if (*ptr == ' ') { ptr++; } /* 如果是其他字符，报错并退出 */ else { printf("Error: unsupported character '%c'\n", *ptr); exit(1); } } /* 将剩余的运算符出栈并计算结果 */ while (op_top >= 0) { Operator top_op = op_stack[op_top--]; double b = num_stack[num_top--]; double a = num_stack[num_top--]; num_stack[++num_top] = calculate(a, b, top_op); } /* 返回最终结果 */ return num_stack[num_top]; } int main() { char expr[MAX_LENGTH]; printf("请输入表达式：\n"); fgets(expr, MAX_LENGTH, stdin); printf("计算结果为：%.2f\n", evaluate(expr)); return 0; } ``` 这个实现并不完善，还有很多可以改进的地方，例如支持括号、更完善的错误处理等等。但是它可以作为一个入门级的示例，帮助你了解字符串四则运算计算的基本思路。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

sdhongjun

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值