2024.9.24 作业

My_string类中的所有能重载的运算符全部进行重载+、[] 、>、=、>)

仿照stack类实现my_stack,实现一个栈的操作

#include <iostream>
#include <cstring>

using namespace std;


class My_string{
private:
    char *ptr;
    int size;
    int len;

public:
    //无参构造
    My_string():size(15){
        this->ptr=new char[size];
        this->ptr[0]='\0';
        this->len=0;
    }
    //有参构造
    My_string(const char*src):len(0){
        len=strlen(src);
        this->size=this->len+1;
        this->ptr=new char[size];
        strcpy(ptr,src);
    }
    My_string(int num,char value):size(num+1),len(num){
        ptr=new char[size];
        for(int i=0;i<len;i++){
            ptr[i]=value;
        }
        ptr[len]='\0';
    }
    //拷贝构造
    My_string(const My_string&other){
        size=other.size;
        len=other.len;
        ptr=new char[other.size];
        strcpy(ptr,other.ptr);

    }
    //拷贝赋值
    My_string& operator=(const My_string&other){
        if(this==&other){
            return *this;
        }
        size=other.size;
        len=other.size;
        ptr=new char[other.size];
        strcpy(ptr,other.ptr);
    }

    //析构
    ~My_string(){
        delete[] ptr;
    }

    //判空
    bool isempty(){
        return len==0;
    }

    //尾插
    void push_back(char value){
       if(len+1>=size){
           size+=1;
           char *new_ptr=new char(size);
           strcpy(new_ptr,ptr);
           delete []ptr;
           ptr=new_ptr;
       }
       ptr[len++]=value;
       ptr[len]='\0';
    }

    //尾删
    void pop_back(){
        if(len>0){
        ptr[--len]='\0';
    }
    }

    //at
    char &at(int index){
        return ptr[index];
    }

    //清空
    void clear(){
        len=0;
        ptr[0]='\0';
    }

    //获取c风格字符串
    void *data(){
        return ptr;
    }

    //获取实际长度
    int get_length(){
        return len;
    }

    //获取最大容量
    int get_size(){
        return size;
    }

    //二倍扩充，注意new_ptr不需要delete回收是因为这个是栈空间，函数结束会自动回收。
    void double_capacity(){
        size*=2;
        char *new_ptr=new char[size];
        strcpy(new_ptr,ptr);
        delete []ptr;
        ptr=new_ptr;
    }

    My_string operator+(const My_string&other)const{
        My_string result;
        result.len=len+other.len;
        result.size=result.len+1;
        result.ptr=new char[result.size];
        strcpy(result.ptr,ptr);
        strcat(result.ptr,other.ptr);
        //虽然result在栈上的空间会自动释放，注意result的数组不是，需要析构函数手动删除
        return result;
    }

    My_string& operator+=(const My_string&other){
        len+=other.len;
        if(len+1>size){
            size=len+1;
            char *new_ptr=new char[size];
            strcpy(new_ptr,ptr);
            strcat(new_ptr,other.ptr);
            delete [] ptr;
            ptr=new_ptr;
        }else{
            strcat(ptr,other.ptr);
        }
        return *this;

    }

    My_string& operator+=(char value){
        push_back(value);
        return *this;
    }

    bool operator<(const My_string&other)const{
        return strcmp(ptr,other.ptr)<0;
    }
    bool operator>(const My_string&other)const{
        return strcmp(ptr,other.ptr)>0;
    }

    bool operator<=(const My_string&other)const{
        return strcmp(ptr,other.ptr)<=0;
    }
    bool operator>=(const My_string&other)const{
        return strcmp(ptr,other.ptr)>=0;
    }
    bool operator==(const My_string&other)const{
        return strcmp(ptr,other.ptr)==0;
    }
    friend ostream&operator<<(ostream&os,const My_string&str){
        os<<str.ptr;
        return os;
    }
    friend istream& operator>>(istream&is,My_string&str){
        char buffer[1024];
        is>>buffer;
        str=My_string(buffer);
        return is;
    }


};

class My_stack{
private:
    int* data;
    int capacity;
    int top;
public:
    My_stack(int size=10):capacity(size),top(-1){
        data=new int[size];
    }
    ~My_stack(){
        delete []data;
    }
    void double_size(){
        capacity=2;
        int *new_ptr=new int[capacity];
        for(int i=0;i<=top;i++){
            new_ptr[i]=data[i];
        }
        delete []data;
        data=new_ptr;
    }
    bool isempty(){
        return top==-1;
    }
    void push(const int&value){
        if(top+1>=capacity){
            double_size();
        }
        data[++top]=value;
    }

    void pop(){
        if(isempty())return;
        else --top;
    }
    int get_top(){
        return data[top];
    }
    void swap(int index1,int index2){
        int temp=data[index1];
        data[index1]=data[index2];
        data[index2]=temp;
    }
};

int main()
{
    My_string str1("Hello");
    My_string str2(" World");
    My_string str3 = str1 + str2;

    cout << "连接 " << str3 << endl;

    My_string str4;
    cout << "输入 ";
    cin >> str4;
    cout << "输入了" << str4 << endl;

    return 0;
}