【C++】day5

仿string类，写myString类

在这里插入代码片
#include <iostream>
#include<string.h>

using namespace std;

class myString
{
    private:
        char *str;          //记录c风格的字符串
        int size;            //记录字符串的实际长度
    public:
        //无参构造
        myString():size(10)
        {
            str = new char[size];         //构造出一个长度为10的字符串
            strcpy(str,"");         //赋值为空串
        }
        //有参构造
        myString(const char *s)          //string  s("hello world")
        {
            size = strlen(s);
            str = new char[size+1];
            strcpy(str, s);
        }

        //拷贝构造
        myString(const myString & other){
            size = other.size;
            str = new char[size+1];
            strcpy(str, other.str);
        }

        //析构函数
        ~myString(){
            delete [] str;
        }

        //拷贝赋值函数
        myString &operator=(const myString & other){
            if(this != &other){
                delete [] str;
                size = other.size;
                str = new char[size+1];
                strcpy(str, other.str);
            }

            return *this;
        }

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

        //size函数
        int getsize(){
            return size;
        }

        //c_str函数,返回一个指向字符串的指针
        const char* c_str(){
            return str;
        }

        //at函数
        char &at(int pos){
            return str[pos];
        }

        //加号运算符重载
        const myString operator+(const myString &R) const{
            myString temp;
            temp.size = this->size + R.size;
            strcpy(temp.str,this->str);
            strcat(temp.str, R.str);

            return temp;
        }

        //加等于运算符重载
        myString &operator+=(const myString &R){
            this->size += R.size;
            strcat(this->str, R.str);

            return *this;
        }

        //关系运算符重载（>）
        bool operator>(const myString &R)const{
            return this->size>R.size;
        }

        void show(){
            cout << this->str << endl;
        }

        //等号运算符重载
        myString operator=(myString &R){
            this->size += R.size;
            strcpy(this->str, R.str);

            return *this;
        }

        //等等于运算符重载
        bool operator ==(const myString &R){
            if(strcmp(this->str, R.str) == 0){
                return true;
            }else{
                return false;
            }
        }

        //不等于运算符重载
        bool operator !=(const myString &R){
            if(strcmp(this->str,R.str) == 0){
                return false;
            }else{
                return true;
            }
        }

        //小于运算符重载
        bool operator <(const myString &R){
            if(strcmp(this->str,R.str) < 0){
                return false;
            }else{
                return true;
            }
        }

        //小于等于运算符重载
        bool operator <=(const myString &R){
            if(strcmp(this->str,R.str) == 0 || strcmp(this->str,R.str) < 0){
                return false;
            }else{
                return true;
            }
        }

        //大于运算符重载
        bool operator >(const myString &R){
            if(strcmp(this->str,R.str) > 0){
                return false;
            }else{
                return true;
            }
        }

        //大于等于运算符重载
        bool operator >=(const myString &R){
            if(strcmp(this->str,R.str) == 0 || strcmp(this->str,R.str) > 0){
                return false;
            }else{
                return true;
            }
        }


};


int main()
{
/*
    myString s1("muwanluo");
    //调用判空函数
    if(s1.empty()){
        cout << "不为空！" << endl;
    }else{
        cout << "为空！" << endl;
    }
    s1.show();

    //调用获取大小函数
    cout << "s1.size = " << s1.getsize() << endl;

    //调用at函数
    cout << "s1.size = " << s1.at(1) << endl;

    myString s2("yjc");

    myString s3;
    //调用加号运算符重载
    s3 = s1+s2;
    s3.show();

    //调用加等于运算符重载
    s3 += s1;
    s3.show();
*/
    myString s1("muwanluo");
    myString s3("yjc");

    s1.show();
    s3.show();
    //调用>运算符重载
    if(s3 > s1){
        cout << "s3大" << endl;
    }else{
        cout << "s1大" << endl;
    }

    //调用等等于运算符重载
    if(s1 == s3){
        cout << "s1字符串与s3大小相等" << endl;
    }else{
        cout << "s1字符串与s3大小不相等" << endl;
    }

    //调用不等于运算符重载
    if(s1 != s3){
        cout << "s1字符串与s3大小不相等" << endl;
    }else{
        cout << "s1字符串与s3大小相等" << endl;
    }

    //调用小于运算符重载
    if(s1 < s3){
        cout << "s1字符串大小小于s3" << endl;
    }else{
        cout << "s1字符串大小大于s3" << endl;
    }

    //调用小于等于运算符重载
    if(s1 <= s3){
        cout << "s1字符串小于等于s3" << endl;
    }else{
        cout << "s1字符串不小于等于s3" << endl;
    }

    //调用大于运算符重载
    if(s1 > s3){
        cout << "s1字符串大小大于s3" << endl;
    }else{
        cout << "s1字符串大小大于s3" << endl;
    }

    //调用大于等于运算符重载
    if(s1 >= s3){
        cout << "s1字符串大于等于s3" << endl;
    }else{
        cout << "s1字符串大于等于s3" << endl;
    }


    return 0;
}

继承过程中特殊成员函数相关代码

在这里插入代码片
#include <iostream>

using namespace std;

class Father
{
protected:
    string name;

public:
    //无参构造
    Father(){
        cout << "Father::无参构造" << endl;
    }
    //有参构造
    Father(string n): name(n){
        cout << "Father::有参构造" << endl;
    }
    //拷贝构造
    Father(const Father&other):name(other.name){
        cout << "Father::拷贝构造" << endl;
    }
    //拷贝复制
    Father &operator=(const Father&other){
        if(this != &other){
            this->name = other.name;
        }
        cout << "拷贝赋值函数" << endl;
        return *this;
    }
    //析构函数
    ~Father(){
        cout << "Father::析构函数" << endl;
    }

};

class Son:public Father
{
private:
    string toy;

public:
    //无参构造
    Son(){
        cout << "Son::无参构造" << endl;
    }
    //有参构造
    Son(string n,string t):Father(n), toy(t){
        cout << "Son::有参构造" << endl;
    }
    //析构函数
    ~Son(){
        cout << "Son::析构函数" << endl;
    }
    //拷贝赋值函数
    Son &operator=(const Son &other){
        if(this != &other){
            Father::operator=(other);
            this->toy = other.toy;
        }
        cout << "Father::拷贝赋值函数" << endl;
        return *this;
    }

    void show(){
        cout << "name = " << name  << "  toy = " << toy << endl;
    }

};



int main()
{
    Son s1;
    Son s2("muwanluo", "car");
    Son s3(s2);

    s1 = s3;
    s1.show();

    return 0;
}

思维导图