C++自己写类 和 运算符重载函数

1.各类函数要求

1：析构函数，释放buf指向的堆空间

2：编写 append(const mystring r) 为当前字符串尾部，拼接新的字符串r

3：编写 isEqual(const mystring r) 判断当前字符串和 字符串 r是否相等

4.为mystring类补充深拷贝功能的拷贝构造函数

5.为mystring类补充： swap(另一个对象) 的函数，实现交换2个对象的字符串 mystring str = "hello" mystring ptr = "world" str.swap(ptr) str == "world",ptr == "hello"

2.各类运算符重载要求

为之前写的mystring类，添加 + 功能

：本质就是append str1 = "hello" str2 = "world" str3 = str1 + str2 == "helloworld"

+= 功能

= 深拷贝功能

== 功能

!= 功能

++ 功能，字符串中所有字符的ASCII自增1

[] 下表运算符 operator[](int index) 返回该下标上的字符 str = "hello" cout << str[0] ;终端输出 h

cout 输出mystring功能

cin 输入mystring功能

using namespace std;
class mystring
{
    char * buf; //基本数据类型
public:
    mystring(const char * str); //绑定一个构造函数
    mystring(); //绑定另外一个构造函数
    ~mystring(); //析构函数
    void show(); //绑定显示方法
    void setmystring(const mystring r); // 设置字符串
    const char * getmystring()const; //获取当前字符串
    void append(const mystring r); //为当前字符串尾部拼接字符串r
    bool isEqual(const mystring r); //字符串比较否相等
    void swapmystring(mystring& r); //字符串交换
    mystring(const mystring& r); //深拷贝构造函数
    friend mystring operator+(mystring& ,const mystring& ); //加法运算符
    friend mystring operator+=(mystring& ,const mystring &); //复合运算
    mystring operator=(const mystring & r) //深拷贝功能 由于等号=不能放在外面 参数不和 需要写成类函数方法
    {
        int len = strlen(r.buf);
        this->buf = new char[len+1];
        strcpy(buf,r.buf);
        return *this;
    }
    friend bool operator==(const mystring& ,const mystring& ); //字符串相等函数
    friend bool operator!=(const mystring& ,const mystring& ); //字符串不等
    //++ 自增功能重载成字符串中的所有字符ASKII加1
    mystring& operator++()//前++
    {
        for(int i =0;buf[i] != '\0';i++)
        {
            buf[i]++;
        }
        return *this; //返回本身
    }
    mystring operator++(int)//后++
    {
        mystring temp = *this;
        ++(*this);
        return temp; //返回未加前
    }
    char& operator[](int index)  //下标运算符[]
    {
        return buf[index];
    }
    friend ostream& operator<<(ostream& ,const mystring&); //cout输出mystring
    friend istream& operator>>(istream& ,mystring&); //cin输入mtstring


};
//+运算符重载成字符串拼接函数
mystring operator+(mystring& l,const mystring& r)
{
    mystring temp;
    temp.buf = new char[strlen(l.buf)+strlen(r.buf)];
    strcpy(temp.buf,l.buf);
    temp.append(r);
    return temp;
}
//+=运算符重载成字符串追加函数
mystring operator+=(mystring& l,const mystring &r)
{
    l.append(r);
    return l;
}
// == 运算符重载成字符串相等函数
bool operator==(const mystring& l,const mystring& r)
{
    if(strcmp(l.buf,r.buf) == 0)
    {
        return 1;
    }
    return 0;
}
//!= 运算符重载成字符串不等函数
bool operator!=(const mystring&l,const mystring& r)
{
    if(strcmp(l.buf,r.buf) != 0)
    {
        return 1;
    }
    return 0;
}
//<<因为<<cout 是ostream的类 传入的参数应该ostream& 不能是this指针 不能写成类函数只能写在外部
//返回值是ostream类型的
ostream& operator<<(ostream& out,const mystring& r)
{
    out << r.buf ;
    return out;
}
//同理>>
istream& operator>>(istream& in,mystring& r)
{
    in >> r.buf;
    return  in;
}
mystring::~mystring() //析构函数
{
    free(buf);
}

mystring::mystring()  //无参构造函数
{
    buf = (char *)calloc(1,1);
}

mystring::mystring(const char * str) //有参构造函数
{
    int len = strlen(str);
    buf = (char *)calloc(1,len+1);
    strcpy(buf,str);
}

void mystring::show() //打印函数
{
    cout << buf << endl;
}

void mystring::setmystring(const mystring r) //设置当前字符串
{
    free(this->buf);
    int len = strlen(r.buf);
    this->buf = (char *)calloc(1,len+1);
    strcpy(this->buf,r.buf);
}

const char* mystring::getmystring()const //获取当前字符串
{
    return buf;
}

void mystring::append(const mystring r) //追加函数
{
    int m = strlen(this->buf);
    int n = strlen(r.buf);
    int len = m+n;
    char* temp = buf;
    buf = (char* )calloc(1,len+1);
    strcpy(buf,temp);
    free(temp);
    strcat(buf,r.buf);
}

bool mystring::isEqual(const mystring r) //判断是否相等
{
    return strcmp(buf,r.buf) == 0;
}

void mystring::swapmystring(mystring& r) //字符串交换函数
{
    char* temp = this->buf;
    this->buf = r.buf;
    r.buf = temp;
}
mystring::mystring(const mystring& r) //深拷贝构造函数
{
    int len = strlen(r.buf);
    buf = (char* )calloc(1,len+1);
    strcpy(buf,r.buf);
}

int main()
{
    //+测试
    mystring str1 = "hello";
    mystring str2 = "world!";
    mystring str3 = str1 + str2;
    str3.show();
    //+=测试
    mystring str4 = "godbay";
    mystring str5 = "nono";
    str4 += str5;
    str4.show();
    //=测试
    mystring str6 ="nihao";
    str6 = "nibuhao";
    str6.show();
    //==测试
    if(str6 == str5)
    {
        cout << "相等" << endl;
    }
    else {
        cout << "不等" << endl;
    }
    //!=测试

    if(str5 != str6)
    {
        cout << "不相等" << endl;
    }
    else {
        cout << "相等" << endl;
    }
    //[]下标运算符测试
    cout << str1[0] << endl;
    //测试cout cin
    mystring str8;
    mystring str9 = "下班下班，回家睡觉了";
    cin >>  str8;
    cout << str9 << endl;
    /*str.show();
    ptr.setmystring(str);
    ptr.show();


    ptr.setmystring("godbay,world!");
    ptr.show();

    str.append(ptr);
    str.show();

    if(str.isEqual(ptr))
    {
        cout << "str = ptr" << endl;
    }
    */

    return 0;
}