C++运算符重载 （9.2）

 将mystring中能实现的操作都实现一遍

#include <iostream>
#include <cstring>
#include <string.h>

using namespace std;

class Mystring
{
private:
    char *str;
    int size;       //记录字符串的实际长度

public:
    Mystring():size(10)       //无参构造
    {
       str = new char[size];
    }
    Mystring(const char *p)     //有参构造
    {
        size=strlen(p);
        str = new char[size+1];
        strcpy(str,p);
    }
    ~Mystring(){if(str)delete []str;}       //析构函数

    //重载 = 使用对象赋值
    Mystring &operator=(const Mystring &s)
    {
        if (this != &s)
        { // 自赋值检查
            delete[] str; // 释放当前对象的内存
            size = s.size;
            str = new char[size]; // 分配新内存
            strcpy(str, s.str); // 复制字符串
        }
        return *this;
    }

    //重载 = 使用字符串赋值
    Mystring &operator=(const char *p)
    {
        strcpy(this->str,p);
        this->size=strlen(p)+1;
        return *this;
    }

    //访问指定字符，有边界检查
    char &at(int index)
    {
        if(index<0 || index>=size)
        {
            cout<<"越界"<<endl;
        }
        return *(str+index);
    }

    //重载下标运算符[]
    const char &operator[](int index)const
    {
        if(index<0 || index>=size)
        {
            cout<<"越界"<<endl;
        }
        return *(str+index);
    }

    //返回指向字符串首字符的指针
    char *my_data()
    {
        return str;
    }

    //返回字符串的不可修改的C字符数组版本
    const char *c_str()const
    {
        return str;
    }

    //判空函数
    bool empty()
    {
        if(size == 0)
        {
            return 1;
        }else
        {
            return 0;
        }
    }

    //返回字符数
    int length()const
    {
        return size;
    }

    //capatity 函数
    int capatity()const
    {
        return size+1;
    }

    //clear 函数
    void my_clear()
    {
        if(str)
        {
            str[0]='\0';
            size=0;
        }
    }

    //push_back 函数 后附字符到结尾
    void push_back(char c)
    {
        str[size++] = c; // 在末尾添加字符，并更新长度
        str[size] = '\0'; // 确保字符串以空字符结尾
    }

    //pop_back 函数 移除末尾字符
    void pop_back()
    {
        str[size--]='\0';
    }

    //append 函数 后附字符到结尾
    void append(char c)
    {
        str[size++] = c; // 在末尾添加字符，并更新长度
        str[size] = '\0'; // 确保字符串以空字符结尾
    }

    //重载+=
    Mystring &operator+=(char *c)
    {
        strcat(str,c);
        size++;
        return *this;
    }

    //重载 +
    Mystring operator+(const Mystring &p)const
    {
        Mystring temp(*this);
        temp.size+=p.size;
        strcat(temp.str,p.str);
        return temp;
    }

    //重载 ==
    bool operator==(const Mystring &R)const
    {
        return strcmp(this->str,R.str)==0;
    }
    //重载 ！=
    bool operator!=(const Mystring &R)const
    {
        return strcmp(this->str,R.str)!=0;
    }
    //重载 <
    bool operator<(const Mystring &R)const
    {
        return this->size<R.size;
    }
    //重载 >
    bool operator>(const Mystring &R)const
    {
        return this->size>R.size;
    }
    //重载 <=
    bool operator<=(const Mystring &R)const
    {
        return (this->size<R.size || strcmp(this->str,R.str)==0);
    }
    //重载 >=
    bool operator>=(const Mystring &R)const
    {
        return (this->size>R.size || strcmp(this->str,R.str)==0);
    }
    //重载 <<
    friend ostream & operator<<(ostream &L, const Mystring &R);
    //重载 >>
    friend std::istream& operator>>(std::istream& is, Mystring& strObj);
    // 自定义转换函数
        int toInt() const
        {
            return std::stoi(std::string(c_str()));
        }

        long toLong() const
        {
            return std::stol(std::string(c_str()));
        }

        long long toLongLong() const
        {
            return std::stoll(std::string(c_str()));
        }

        unsigned long toUnsignedLong() const
        {
            return std::stoul(std::string(c_str()), nullptr, 10); // 假设十进制
        }

        unsigned long long toUnsignedLongLong() const
        {
            return std::stoull(std::string(c_str()), nullptr, 10); // 假设十进制
        }

        float toFloat() const
        {
            return std::stof(std::string(c_str()));
        }

        double toDouble() const
        {
            return std::stod(std::string(c_str()));
        }


};
//自定义输出运算符重载函数：只能实现全局函数版
ostream & operator<<(ostream &L, const Mystring &R)
{
    //输出内容
    if(R.size!=0)
    {
        L<<R.str<<endl;
    }
    //返回左操作数自身
    return L;
}
//自定义输入运算符重载函数：只能实现全局函数版
std::istream& operator>>(std::istream& is, Mystring& strObj) {
    // 释放旧内存（如果有的话）
    delete[] strObj.str;

    // 读取一行到临时缓冲区中（这里使用 std::getline）
    std::string temp;
    std::getline(is, temp);

    // 分配新内存以存储读取的字符串
    strObj.size = temp.size();
    strObj.str = new char[strObj.size + 1];

    // 复制字符串到新内存
    std::strcpy(strObj.str, temp.c_str());

    // 返回输入流以支持链式调用
    return is;
}



int main()
{
    Mystring s1;
    s1="123456";
    cout<<s1<<endl;
    return 0;
}