C++day5(运算符重载、静态成员函数、静态成员变量、类的继承)

my_string类的运算重载 

#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)
    {
        size=strlen(s);
        str=new char[size+1];
        strcpy(str,s);
    }

    //拷贝构造
    mystring (const mystring &other):str(new char[other.size+1]),
        size(other.size)
    {
        strcpy(this->str,other.str);
    }
    //析构函数
    ~mystring()
    {
        delete []str;
        str=nullptr;
    }
    //拷贝赋值函数
    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 mystring_empty(char *s)
    {
        if(strlen(s)==0)
            return 1;
        else
            return 0;
    }
    //size函数
    void mystring_size()
    {
        cout<<strlen(str)<<endl;
    }
    //c_ str函数
    char *c_str()
    {
        return str;
    }
    //at函数
    char &mystring_at(int pos)
    {
        return this->str[pos];
    }

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

    //关系运算符重载(>)
    bool operator>(const mystring &R)const
    {
        if(strcmp(this->str,R.str)>=0)
            return 1;
        else
            return 0;
    }
    //加等于运算符重载
     mystring &operator+= (const mystring &R)
    {
       strcat(this->str,R.str);
        return *this;
    }

    //全局函数版完成  插入运算符   重载函数
    friend ostream &operator<<(ostream &L,const mystring &R);
    //全局函数版完成  提取运算符   重载函数
    friend istream &operator>>(istream &L,const mystring &R);


    //成员函数版实现中括号运算符
    char &operator [](const int pos)
    {
        if(pos<0||pos>size)
            cout<<"给定下标不合法"<<endl;
        while(str!=0)
        {
            return str[pos];
        }
    }

    void show()
    {
       cout<<str<<endl;
    }

};

//全局函数版完成  插入运算符   重载函数
ostream &operator<<(ostream &L,const mystring &R)
{
    L<<R.str<<endl;;
    return L;
}
//全局函数版完成  提取运算符   重载函数
istream &operator>>(istream &L,const mystring &R)
{
    L>>R.str;
    return L;
}

int main()
{
    mystring s1("hello");
    s1.show();
    s1.mystring_size();
    cout<<s1.mystring_at(2)<<endl;

    mystring s2;
    s2=s1;
    s2.show();

    mystring s3=s2+s1;
    s3.show();

    mystring s4;
    s4+=s1;
    s4.show();

    cout<<"********************"<<endl;

    cout<<s1;
    mystring s5;
    cin>>s5;
    cout<<"s5= "<<s5<<endl;

    cout<<s5[2]<<endl;
    if(s3>s1)
    {
        cout<<"yes"<<endl;
    }
    else
        cout<<"no"<<endl;

    return 0;
}

继承

#include <iostream>

using namespace std;


class Person
{
protected:
    int id;    //身份证
public:
    string name;
    int age;
    Person(){cout<<"Person::无参构造"<<endl;}
    Person(int i,string n,int a):id(i),name(n),age(a)
    {cout<<"Person::有参构造"<<endl;}
    ~Person(){cout<<"Person::析构函数"<<endl;}
    //拷贝构造
    Person(const Person &other):id(other.id),name(other.name),age(other.age)
    {
        cout<<"Person::拷贝构造"<<endl;
    }
    //拷贝赋值
    Person& operator=(const Person &other)
    {
        this->id=other.id;
        this->name=other.name;
        this->age=other.age;
        return *this;
    }

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

class Stu:public Person
{
private:
    double score;   //分数
public:
    Stu(){cout<<"Stu::无参构造"<<endl;}
    Stu(int i,string n,int a,double s):Person(i,n,a),score(s)
    {cout<<"Stu::有参构造"<<endl;}
    ~Stu(){cout<<"Stu::析构函数"<<endl;}

    //拷贝构造
    Stu(const Stu &other):Person(other),score(other.score)
    {
        cout<<"Stu::拷贝构造"<<endl;
    }
    //拷贝赋值
    Stu& operator =(const Stu &other)
    {
        if(this!=&other)
        {
            Person::operator=(other);
            score=other.score;
        }
        cout<<"Stu::拷贝赋值函数"<<endl;
        return *this;
    }

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

};
int main()
{
    Stu s1(340256,"zhangsan",26,98.5);
    s1.show();
    Stu s2(s1);
    s2.name="lihua";
    s2.show();
    return 0;
}