9.24My_string类中的所有能重载的运算符全部进行重载+、[] 、＞、＜、==、＞=、＜=、!= 、+=（可以加等一个字符串，也可以加等一个字符）、输入输出(＜＜ 、 ＞＞)

text.h

#include <iostream>
#ifndef TEXT_H
#define TEXT_H




using namespace std;


class My_string
{
private:
    char *ptr;         //指向字符数组的指针
    int size;           //字符串的最大容量
    int len;            //字符串当前容量


public:
     //无参构造
    My_string();
     //有参构造
    My_string(const char* src);
    My_string(int num, char value);

    //拷贝构造
    My_string(const My_string& other);
    //拷贝赋值
    My_string& operator=(const My_string & other);
    //析构函数
  ~My_string();
    //判空
    bool is_empty()const;
    //尾插
    void push_back(char value);
    //尾删
    void pop_back();
    //at函数实现
    char &at(int index);
    //清空函数
    void clear();
    //返回C风格字符串
    char *data();
    //返回实际长度
    int get_length();
    //返回当前最大容量
    int get_size();

    //君子函数:二倍扩容

    // 扩容函数，动态扩展字符串的容量
    void my_resize(int new_size);
    char * show();
    // + 运算符
    My_string operator+(const My_string &R)const;
    // [] 运算符
    char& operator[](int a);
    // > 运算符
    bool operator>(const My_string& other) const ;
    // < 运算符
    bool operator<(const My_string& other) const;
    // == 运算符
    bool operator==(const My_string& other) const;
    // >= 运算符
    bool operator>=(const My_string& other) const ;
    // <= 运算符
    bool operator<=(const My_string& other) const ;
    // != 运算符
    bool operator!=(const My_string& other) const ;
};

#endif // TEXT_H

text.c

#include "text.h"
#include <cstring>


//无参构造
My_string::My_string():size(15)
{
    this->ptr = new char[size];
    this->ptr[0] = '\0';            //表示串为空串
    this->len = 0;
}

//有参构造
//1 从字符串构造的构造函数
My_string::My_string(const char *src)
{
    len =strlen(src); //计算字符串换长度
    size=len+1;         //+1 留出终止符
    ptr=new char[size];  //分配字符数组
    strcpy(ptr,src);    //添加字符串到数组
}
//2 从字符和数量构造的构造函数
My_string::My_string(int num, char value)
{
    size=num+1;  //+1留出终止符
    len=num;       //实际长度
    ptr=new char[size];
    for(int i=0;i<len;i++)
    {
        ptr[i]=value;
    }
    ptr[len]='\0';

}
//拷贝构造
My_string::My_string(const My_string& other)
{
    this->size=other.size;
    this->len=other.len;
    this->ptr=new char[this->size];
    strcpy(ptr,other.ptr);
}
//拷贝赋值
My_string& My_string::operator=(const My_string & other)
{
    if(this!=&other)
    {
        delete[]ptr; //释放原有内存
        this->size=other.size;
        this->len=other.len;
        this->ptr=new char[this->size];
        strcpy(this->ptr,other.ptr);
    }
    return *this;
}
//析构函数
    My_string::~My_string()
{
    delete [] this->ptr;    //释放内存
}
    //判空
    bool My_string::is_empty()const
    {
        return  len==0;
    }
    //尾插
void My_string::push_back(char value)
{
if (len + 1 >= size)
        {
           // 扩容
          my_resize(size * 2);
       }

        ptr[len++]=value;  //加入字符
        ptr[len]='\0';
 }
    //尾删
void My_string::pop_back()
    {
     if(len>0)  //判断是否可以删除
     {
         len--;   //长度-1
         ptr[len]='\0';
     }
    }
 //at函数实现
char & My_string::at(int index)
{
    if(index>=0&&index<size)
    {
        return  ptr[index];
    }
    else{
        cout<<"超出范围 "<<endl;
        exit(1);   //终止程序
    }
}

    //清空函数
void My_string:: clear()
    {
        this->len=0; //重置长度
        ptr[0]='\0';  //置空

    }


    //返回C风格字符串
 char * My_string::data()
 {
     return ptr;
 }
    //返回实际长度
    int My_string::get_length()
    {
        return len;
    }
    //返回当前最大容量
    int My_string::get_size()
    {
        return  size;
    }

    //君子函数:二倍扩容
void My_string::my_resize(int new_size)
{
        char* new_ptr = new char[new_size]; // 动态分配新数组
        strcpy(new_ptr, ptr); // 复制旧数据
        delete[] ptr; // 释放旧内存
        ptr = new_ptr; // 更新指针
        size = new_size; // 更新大小
 }
char * My_string::show()
{
    return ptr;
}
// 定义 + 运算符重载函数
My_string My_string::operator+(const My_string &R)const
{
    My_string new_ptr(this->len+R.len,' ');
    strcpy(new_ptr.ptr,this->ptr);
    strcat(new_ptr.ptr,R.ptr);
    new_ptr.len=this->len+R.len;
    return  new_ptr;
}
// 定义[] 运算符重载函数
char& My_string::operator[](int a)
{
    return  at(a);
}

bool My_string::operator>(const My_string& other) const {
    return strcmp(ptr, other.ptr) > 0; // 字符串比较
}

bool My_string::operator<(const My_string& other) const {
    return strcmp(ptr, other.ptr) < 0; // 字符串比较
}

bool My_string::operator==(const My_string& other) const {
    return strcmp(ptr, other.ptr) == 0; // 字符串比较
}

bool My_string::operator>=(const My_string& other) const {
    return !(*this < other); // 使用 < 运算符
}

bool My_string::operator<=(const My_string& other) const {
    return !(*this > other); // 使用 > 运算符
}

bool My_string::operator!=(const My_string& other) const {
    return !(*this == other); // 使用 == 运算符
}

main.c

#include <iostream>
#include "text.h"

using namespace std;


int main()
{

//        My_string str("AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA"); // 使用 C 字符串初始化
//        str.push_back('q'); // 尾插字符
//        std::cout << "输出为: " << str.data() << std::endl; // 输出:
//        std::cout << "实际长度: " << str.get_length() << std::endl; // 输出  实际长度
//        std::cout << "总长度: " << str.get_size() << std::endl; // 输出总长度

//        str.pop_back(); // 尾删字符
//        std::cout << "删除后的数据为: " << str.data() << std::endl; // 输出: Hello
//        str.clear(); // 清空字符串
//        std::cout << "清空后的内容为 " << str.data() << std::endl; // 输出: (空字符串)
        My_string str_1("hello ");
        My_string str_2("world ");
        My_string str_3=str_1+str_2;
        std::cout << "拼接后的字符串为: " << str_3.show() << std::endl; // 输出拼接后的字符串
        cout<<str_3[4]<<endl;
        cout<<(str_1>str_2)<<endl;
        cout<<(str_1>=str_2)<<endl;
        cout<<(str_1<=str_2)<<endl;
        cout<<(str_1<str_2)<<endl;
        cout<<(str_1==str_2)<<endl;
        cout<<(str_1!=str_2)<<endl;
        return 0;


}