C++学习11-String类型 & 大数加减

String类型

以后处理字符串可以直接用String类型 #include
编程能力强不强=处理字符串的能力强不强

C++中的string是一个标准库类型，表示可变长的字符序列，而由于是标准库类型，所以string定义在命名空间std中
ps:
1.得到字符串长度 str2.length()
2.底层是动态的 所以定义指针好
3.字符串哲学系都可能用完释放 所以要提供右值
4.常对象调不了普通方法,所以只读不写都定义为常方法

自写C++标准库中的String类型

class CMyString
{
public:
    CMyString(const char*p = nullptr)
    //本来是一个有参数的,无参数的 我们写一个带默认值的就可以无参数有参数结合在一起
    //无参数的时候p = nullptr 有参数的时候就是用我传入的p
    {
        if (p != nullptr)
        {
            // 1.根据p指向得字符串得长度，开辟一块内存空间
            mptr = new char[strlen(p) + 1];
            // 2.把p指向得字符串拷贝到这块空间上来
            strcpy(mptr, p);
        }
        else
        {
//若p传进来是空的,则mptr开辟的空间也为空,所有自构造的时候就要保证:不管传进来的指针是否为空 都能构造出一个string底层空间不为空
            mptr = new char[1];
            *mptr = 0; // '\0'
        }
    }
    ~CMyString()
    {
        delete []mptr;
        mptr = nullptr;
    }
    CMyString(const CMyString &str)
    {
        mptr = new char[strlen(str.mptr) + 1];
//最好不要写成 mptr = new char[str.length() + 1];因为接口之间不要有依赖性,不然length函数删了就要改好多
        strcpy(mptr, str.mptr);
    }
    CMyString(CMyString &&str)
    {
        mptr = str.mptr;
        str.mptr = nullptr;
    }
    // str1 = str2.operator=(str3);
    CMyString& operator=(const CMyString &str)
    {
        if (this == &str)
            return *this;

        delete[]mptr;

        mptr = new char[strlen(str.mptr) + 1];
        strcpy(mptr, str.mptr);
        return *this;
    }
    CMyString& operator=(CMyString &&str)
    {
        if (this == &str)
            return *this;

        delete[]mptr;

        mptr = str.mptr;
        str.mptr = nullptr;
        return *this;
    }


    bool operator>(const CMyString &str)const
    {
        return strcmp(mptr, str.mptr) > 0;
    }
    bool operator<(const CMyString &str)const
    {
        return strcmp(mptr, str.mptr) < 0;
        //strcmp是从两个字符串的第一个字母开始比较 看哪个在前面
    }
    bool operator==(const CMyString &str)const
    {
        return strcmp(mptr, str.mptr) == 0;
    }


    int length()const { return strlen(mptr); }
    char& operator[](int index) { return mptr[index]; }
    //要加& 返回地址,既能读又能写,不然的话只能看到那个值 不能改
    //char是<4 由寄存器返回,那是个立即数,不可写只可读
    const char* c_str()const { return mptr; }
//这个就是只能读 是个常方法

private:
    char *mptr;


    friend ostream& operator<<(ostream &out, const CMyString &str);
    friend CMyString operator+(const CMyString &l, const CMyString &r);
};
CMyString operator+(const CMyString &l, const CMyString &r)
{
    int length = l.length() + r.length();
    char* p = new char[length + 1];
    strcpy(p, l.mptr);
    strcat(p, r.mptr);
    String tmp(p);
    delete []p;
    return tmp;
/*
//不能直接返回构造的这个  因为从始至终没有析构过他 会造成内存泄露所以要写成上面那样 原因在于用指针p指向的内存构造了一个临时对象： CMyString(const char*p = nullptr) 但是这个函数结束了p一直没有被析构掉 所以不能这样做
注意之前用int类型的值构造临时对象返回就不会出现这样的烦恼

但是这样做的效率非常低！！！

    return String(p);

//不能直接这样 因为1里面根本没有充足的空间去接受
    strcat(1.mptr, r.mptr);
*/
}
// CMyString str1 = str2 + str3;
// CMyString str1; str1= str2 + str3;
//访问的是私有成员 所以要声明为友元函数
ostream& operator<<(ostream &out, const CMyString &str)
{
    out << str.mptr;
    return out;
}
istream& operator>>(istream &in, MyString &str)
{
    delete[]str.mpstr;
    str.mpstr = new char[1024];
    in >> str.mpstr;
    return in;
}

int main()
{
    CMyString str1; // string()
    CMyString str2 = "aaa"; // string(const char*p = nullptr)
    CMyString str3 = "bbb";
    CMyString str4 = str2 + str3;
    CMyString str5 = str2 + "ccc";
    CMyString str6 = "ddd" + str3;//同样要提供全局方法

    str6 = str2 + "eee";
    cout << str6 << endl;

    if (str2 > str3)
    {
        cout << "str2 > str3" << endl;
    }

    int size1 = str2.length();
    int size2 = str3.length();


    for (int i = 0; i < str6.length(); ++i)
    {
        // char& operator[](int index)
        // str6[i] = 'a';
        cout << str6[i] << " ";
        //str6[i]比getcharAt(i)要好,因为万一这个str里面存的是数组 每一个str[i]都存的是一个数组 就无法返回了
        //以及要提供方括号的重载方法
    }
    cout << endl;
     
    // string str = "elwiyuiyw7386529"    char* => string
    char *pbuf = new char[str6.length() + 1];//申请空间
    strcpy(pbuf, str6.c_str()); // c_str()  const char*
    //c_str把对象管理的字符串返回char*的数据.用 strcpy进行赋值
    cout << pbuf << endl;
    */


    return 0;
}

写代码的方法:
1.先列逻辑 不要写了又改 要写思路
2.然后再根据思路来写

    // 1.根据p指向得字符串得长度，开辟一块内存空间
    mptr = new char[strlen(p) + 1];
    // 2.把p指向得字符串拷贝到这块空间上来
    strcpy(mptr, p);

上面实现的String类型出现了问题：
对于加法运算符重载函数：

CMyString operator+(const CMyString &l, const CMyString &r)
{
    int length = l.length() + r.length();
    char* p = new char[length + 1];
    strcpy(p, l.mptr);
    strcat(p, r.mptr);
    String tmp(p);
    delete []p;
    return tmp;
}

这样做的效率非常低！！！

解决方法：
定义类对象接收 这样的话在函数结束的时候就可以调用写的析构函数

CMyString operator+(const CMyString &l, const CMyString &r)
{
    int length = l.length() + r.length();
    String tmp;
    tmp.mptr= new char[length + 1];
    strcpy(tmp.mptr, l.mptr);
    strcat(tmp.mptr, r.mptr);
    return tmp;
}

完成大数的加减法

String实现：

1.一个for循环，从后往前同时遍历lhs.strDigit和rhs.strDigit
2.相应的位置进行相加，但是相加的时候需要考虑进位，如果带进位，需要多加一个1
3.加完的结果直接存储，但是如果超过10，只记录%10的余数，然后还要记录进位
4.两个字符串有可能同时加完，也有可能短的完了，长的还没完，把长的直接放入最终结果（还是要考虑进位的）
999999876
     9879

class BigInt
{
public:
        BigInt(const char* digit) :strDigit(digit) {}
private:
        string strDigit;
        friend string operator+(const BigInt &lhs, const BigInt &rhs);
        friend string operator-(const BigInt &lhs, const BigInt &rhs);
};
string operator+(const BigInt &lhs, const BigInt &rhs)
{
        /*
        1.一个for循环，从后往前同时遍历lhs.strDigit和rhs.strDigit
        2.相应的位置进行相加，但是相加的时候需要考虑进位，如果带进位，需要多加一个1
        3.加完的结果直接存储，但是如果超过10，只记录%10的余数，然后还要记录进位
        4.两个字符串有可能同时加完，也有可能短的完了，长的还没完，把长的直接放入最终结果（还是要考虑进位的）
        999999876
                9879
        */
        string result;
        int i = lhs.strDigit.length() - 1;
        int j = rhs.strDigit.length() - 1;
        bool flag = false;
        for (; i >= 0 && j >= 0; --i, --j)
        {
               int sum = lhs.strDigit[i] - '0' + rhs.strDigit[j] - '0';
               if (flag) // 如果低位有进位，处理进位情况
               {
                       sum += 1;
                       flag = false;
               }
               if (sum >= 10) // 当前相应位相加超过10，记录正确的结果和记录进位
               {
                       sum = sum % 10;
                       flag = true;
               }
               result.push_back(sum + '0'); // 把相应位相加的结果进行存储
        }
        for (; i >= 0; --i) // 表示lhs还有剩余
        {
               int sum = lhs.strDigit[i] - '0';
               if (flag)
               {
                       sum += 1;
                       flag = false;
               }
               if (sum >= 10)
               {
                       sum = sum % 10;
                       flag = true;
               }
               result.push_back(sum + '0');
        }
        for (; j >= 0; --j) // 表示lhs还有剩余
        {
               int sum = rhs.strDigit[j] - '0';
               if (flag)
               {
                       sum += 1;
                       flag = false;
               }
               if (sum >= 10)
               {
                       sum = sum % 10;
                       flag = true;
               }
               result.push_back(sum + '0');
        }
        if (flag)
        {
               result.push_back('1');
        }
        i = 0;
        j = result.length() - 1;
        while (i < j)
        {
               char ch = result[i];
               result[i++] = result[j];
               result[j--] = ch;
        }
        return result;
}
string operator-(const BigInt &lhs, const BigInt &rhs)
{
        /*
        先判断谁大谁小
        低位开始相减
        */
        string maxstr = lhs.strDigit;
        string minstr = rhs.strDigit;
        string result;
        bool minor = false;
        bool flag = false;
        if (maxstr.length() < minstr.length())
        {
               maxstr = rhs.strDigit;
               minstr = lhs.strDigit;
               minor = true;
        }
        else
        {
               if (maxstr.length() == minstr.length())
               {
                       if (maxstr < minstr)
                       {
                              maxstr = rhs.strDigit;
                              minstr = lhs.strDigit;
                              minor = true;
                       }
                       else if (maxstr == minstr)
                       {
                              return "0";
                       }
               }
        }
        int i = maxstr.length() - 1;
        int j = minstr.length() - 1;
        for (; i >= 0 && j >= 0; --i, --j)
        {
               int ret = maxstr[i] - minstr[j]; // 3 - 8    -5
               if (flag)
               {
                       ret -= 1;
                       flag = false;
               }
               if (ret < 0)
               {
                       ret += 10;
                       flag = true;
               }
               result.push_back(ret + '0');
        }
        for (; i >= 0; --i)
        {
               int ret = maxstr[i] - '0'; // 3 - 8    -5
               if (flag)
               {
                       ret -= 1;
                       flag = false;
               }
               if (ret < 0)
               {
                       ret += 10;
                       flag = true;
               }
               result.push_back(ret + '0');
        }
        string ret;
        i = result.length() - 1;
        for (; i >= 0; --i)
        {
               if (result[i] != '0')
                       break;
        }
        for (; i >= 0; --i)
        {
               ret.push_back(result[i]);
        }
        if (minor)
        {
               ret = "-" + ret;
        }
        return ret;
}
int main()
{
        BigInt int1("3985629783586723745692364"); // BigInt(const char*)
        BigInt int2("72567537245823985678236");
        //4058197320832547731370600
        cout << int1 + int2 << endl;
        cout << int1 - int2 << endl; // string operator-(xx, xx)
        /*
        99999327
        99999326
        00000001
        */
        BigInt int3("99999327"); // BigInt(const char*)
        BigInt int4("99999326");
        cout << int3 - int4 << endl;
        cout << int4 - int3 << endl;

        return 0;
}

方法二实现：

// 2、编程（网易笔试题）： 请实现以下类的方法，完成大数的加减法（可以使用STL容器）
// 大整数类型
class BigInt
{
public:
    BigInt(string str) :strDigit(str) {}
private:
    string strDigit;   // 使用字符串存储大整数
    friend ostream& operator<<(ostream &out, const BigInt &src);
//输出的参数就是out 所以不能写在类内 写在类内会变成this ostream &out  但是参数的第一个得是out
    friend BigInt operator+(const BigInt &lhs, const BigInt &rhs);
//不写全局函数的话可能会有string+bigint这种现象发生 为了避免麻烦 写成全局
};
ostream& operator<<(ostream &out, const BigInt &src)
{
    out << src.strDigit;
    return out;
}
// 大数加法
BigInt operator+(const BigInt &lhs, const BigInt &rhs)
{
    string result;
    bool flag = false; // 记录进位 默认给的是不进位的参数

    int lsize = lhs.strDigit.length();//保存左边的数的位数
    int rsize = rhs.strDigit.length();

    // 遍历lhs和rhs的字符串
    int i = lsize - 1, j = rsize - 1;//从数字的最后一位相加开始向前移动
    for (; i >= 0 && j >= 0; --i, --j)
    {
        int ret = (lhs.strDigit[i] - '0') + (rhs.strDigit[j] - '0');//数字转字符串
        if (flag)//如果有进位的话
        {
            ret += 1;
            flag = false;
        }
        
        if (ret >= 10)
        {
            ret %= 10;
            flag = true; // 记录需要进位
        }

        result.push_back(ret + '0');//字符串的底层就是一维数组 所以可以一个一个的存储相加后的数字
        //result.insert(result.begin(), ret + '0');
    }


    // i >=0 j >= 0  lhs   有一个位数算到小于零以后就会跳出来 然后开始判断那个没加完
    if (i >= 0)//左右两个数据长短不一样 如果右边加完了
    {
        while (i >= 0)
        {
            int ret = (lhs.strDigit[i] - '0');
            if (flag)
            {
                ret += 1;
                flag = false;
            }
            if (ret >= 10)
            {
                ret %= 10;
                flag = true;
            }
            result.push_back(ret + '0');
            i--;
        }
    }
    else if (j >= 0) // rhs  左边加完了
    {
        while (j >= 0)
        {
            int ret = (rhs.strDigit[j] - '0');
            if (flag)
            {
                ret += 1;
                flag = false;
            }
            if (ret >= 10)
            {
                ret %= 10;
                flag = true;
            }
            result.push_back(ret + '0');
            j--;
        }
    }


    if (flag)
    {
        result.push_back('1');
    }


    reverse(result.begin(), result.end());//string result  string底层是一维数组,同样也封装了迭代器,begin和end方法返回迭代器  reverse把头尾颠倒
    return result;
}
// 大数减法
BigInt operator-(const BigInt &lhs, const BigInt &rhs)
{
        /*
        首先要区分大数和小数  > < 并且要考虑相减的结果是否要加负号 
        */
        string result;
        bool flag = false;
        bool minor = false;
        string maxStr = lhs.strDigit;//所以先假设maxstr>minstr
        string minStr = rhs.strDigit;//strDigit是bigint这个对象的成员 是string类型的
        if (maxStr.length() < minStr.length())
        {
               maxStr = rhs.strDigit;//在这做的处理是永远把大的放在左边 然后加负号是后续的处理
               minStr = lhs.strDigit;
               minor = true;//如果假设错了 则需minor=true来加负号
        }
        else if(maxStr.length() == minStr.length())
        {
               if (maxStr < minStr)
               {
                       maxStr = rhs.strDigit;//在这做的处理是永远把大的放在左边 然后加负号是后续的处理
                       minStr = lhs.strDigit;
                       minor = true;
               }
               else if (maxStr == minStr)//两个一样 则相减为0 
               {
                       return string("0");  // BigInt(string)
               }
        }
        int lsize = maxStr.length();
        int rsize = minStr.length();
        // 遍历lhs和rhs的字符串
        int i = lsize - 1, j = rsize - 1;//string底层是数组,有五个数字存到0~4 所以-1
        for (; i >= 0 && j >= 0; --i, --j)
        {
               int ret = maxStr[i] - minStr[j];//对应位置相减这里直接ASCII码就可以相减
               if (flag)//如果上一位的运算需要借位
               {
                       ret -= 1;//给这一位要-1
                       flag = false;//借位符变为不用借位
               }
               if (ret < 0)
               {
                       ret += 10;//<0借一位
                       flag = true; // 记录需要借位
               }
               result.push_back(ret + '0');//转为字符串再放进去 从尾部放
        }
        // i >=0 j >= 0  lhs   
        while (i >= 0)//因为在前面已经处理过让左边的数字始终大于右边的
        {//所以这里要判断当右边的位数减完了的时候
               int ret = (maxStr[i] - '0');
               if (flag)
               {
                       ret -= 1;
                       flag = false;
               }
               if (ret < 0)
               {
                       ret += 10;
                       flag = true;
               }
               result.push_back(ret + '0');
               i--;
        }
        while (result.back() == '0')//处理一下a-b=0003的情况 把前面存在数组尾部的0都尾部删除
        {
               result.pop_back();
        }
        if (minor)//加负号
        {
               result.push_back('-');
        }
        reverse(result.begin(), result.end());//首尾颠倒
        return result;
}
int main()
{
        BigInt int1("9785645649886874535428765");
        BigInt int2("9785645649886874575648564");
        BigInt int3("9785645649886874535428765");
        //28937707643477817736572188660008
        //28937707643477817736572188660008
        cout << int1 + int2 << endl;
        //28937688072186517962823117802478
        // 28937688072186517962823117802478
        //-28937688072186517962823117802478
        cout << int1 - int2 << endl;
        //deque<int> deq;
        //first    1024     2*i(1024)+1 / 1024 = 2  2*i(1024)+1 % 1024
        //deq[10];
        return 0;
}

注意加减运算对于是否要-'0’的区别:=

对于减法:

int ret = maxStr[i] - minStr[j];//对应位置相减这里直接ASCII码就可以相减

因为:
3—ASCII码52
1—ASCII码50
相减就是2

对于加法:

int ret = (lhs.strDigit[i] - '0') + (rhs.strDigit[j] - '0');

因为相加的话显然不是正确的 所以每个数字都要减去0的ASCII码