7-20_homework

#include <iostream>
#include <cstring>

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(){
            delete []str;  //释放连续的空间
        }
        //
        void show(){
            cout<<"str="<<str<<endl;
        }

        //拷贝构造
        myString(const myString & other)
        {

            size = strlen(other.str);
            str = new char[size+1];
            strcpy(str, other.str);
        }

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


        //判空函数
        bool empty()
        {
            if(0 == *str)
            {
                cout << "空" << endl;
                return false;
            }
            else
            {
                cout << "非空" << endl;
                return true;
            }
        }

        //size函数
        int sizeo(){
            return strlen(str);
        }

        //c_str函数      指针函数，返回一个指针
        char *c_str(){
                return str;
        }

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

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

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

        //>关系运算符重载（>）
        bool operator > (const myString &R)const{
            int n=strcmp(this->str,R.str);
            return n>0;
        }
 /*  ===================   ===========================  ===   */
        //>=
        bool operator >=(const myString&R)const{
            int n=strcmp(this->str,R.str);
            return n>=0;
        }


        //==
        bool operator==(const myString &R)const{
            int n=strcmp(this->str,R.str);
            return n=0;  //如果n=0，返回真
        }


        //!=
        bool operator!=(const myString & R)const{
            int n=strcmp(this->str,R.str);
            return n!=0;
        }


        //[]
        char & operator[](int pos){
            return str[pos];
        }


        //<<  友元函数
        friend ostream & operator <<(ostream &L,const myString &R);


        //>>
        friend istream &operator >> (istream &L,myString &R);


};

ostream & operator <<(ostream &L,const myString &R){
    L<<R.str;
    return L;
}


istream &operator >> (istream &L,myString &R){
    L>>R.str;
    R.size=strlen(R.str);
    return L;
}



int main()
{
    char *s1="hello";
    myString s2(s1);   //拷贝构造
    s2.show();

    myString s3("world");
    s2=s2+s3;
    s2.show();

    s3+=s1;
    s3.show();

    if(s2>s3){
        cout<<"大于"<<endl;
    }else cout<<"不大于"<<endl;

    if(s2==s1){
        cout<<"相等"<<endl;
    }else cout<<"不相等"<<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<<"Father::拷贝赋值函数"<<endl;
        return *this;
    }

    ~Father() {cout<<"Father::析构函数"<<endl;}

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

};


class Son:public Father{
private:
    string toy;
public:
    Son(){cout<<"Son::无参构造"<<endl;}

    Son(string n,string t):Father(n),toy(n) 
    {cout<<"Son::有参构造"<<endl;}

    ~Son() {cout<<"Son::析构函数"<<endl;}

    Son(const Son &other):Father(other),toy(other.toy)   
    {       
        cout<<"Son::拷贝构造"<<endl;
    }

    Son &operator=(const Son &other)
    {
        if(this!=&other){
            Father::operator=(other);  
            this->toy=other.toy;       
        }
    }

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

int main()
{
    Father f1("sss");
    f1.show();

 /*
    cout << "=============" << endl;
    Son s1;
    Son s2("zxc","12");

    Son s3(s2);
    s1=s3;
    s1.show();

    cout << "=============" << endl;
 */
    return 0;
}