类的父子继承概述和练习，及昨日mystring类的运算符扩充

 1、类的父子继承练习

#include <iostream>

using namespace std;

//练习父子类继承
class Father
{
private:
    string name;
    int money;
protected:
    int age;
public:
    double score;
    //无参构造
    Father(){cout<<"无参构造"<<endl;}
    //有参构造
    Father(string n,int m,int a,double s):name(n),money(m),age(a),score(s)
    {
        cout<<"有参构造"<<endl;
    }
    //析构函数
    ~Father(){cout<<this<<"析构函数"<<endl;}

    //打印函数
    void show()
    {
        cout<<name<<" "<<money<<" "<<age<<" "<<score<<endl;
    }

};
class Son:public Father
{
public:
    int tall;
    //无参构造
    Son(){cout<<"无参构造"<<endl;}
    //有参构造
    Son(string n,int m,int a,double s,int t):Father(n,m,a,s),tall(t)
    {
        cout<<"有参构造"<<endl;
    }
    //析构函数
     ~Son(){cout<<"析构函数"<<endl;}
    //打印函数
    void show()
    {
        cout<<" " <<"age ="<<age<<"score ="<<score<<"tall ="<<tall<<endl;
    }
};
int main()
{
    Son s1("shen",18,1,2.3,5);
    s1.show();
    s1.Father::show();
    return 0;
}

2、 基于昨日Mystring类运算符重载又新增<< >> clear [] 函数/运算符重载，并且将昨日代码优化：析构时未释放指针空间，拷贝赋值时未将前空间释放等问题。

#include <iostream>
#include <cstring>
using namespace std;


class Mystring
{
private:
    char *str;     //储存字符串地址
    int size;     //当前字符串长度
public:
    //无参构造
    Mystring():size(10)
    {

        str = new char[size];
        strcpy(str,"");
    }
    //有参构造
    Mystring(const char *s)
    {
        size = strlen(s);   //求得当前字符串长度
        str = new char[size+1];    //创建一个空间储存字符串，+1为了存放'\0'
        strcpy(str,s);
     }
    //拷贝构造（用于类对象给未构造的类进行初始化）
    Mystring(const Mystring &other):    //传字符串地址，来构造一个字符串空间
        str(new char[other.size+1])
    {
        //this->size=strlen(other.str);
        strcpy(this->str,other.str); //用字符串给其初始化
        this->size = other.size;
        cout<<"拷贝构造"<<endl;
    }
    //析构函数
    ~Mystring()
    {
         delete []this->str;
        cout<<"stu::析构构造"<<this<<endl;
    }
//    拷贝赋值函数（）
    Mystring &operator=(const Mystring& other) //myat(s2,s3)
    {
        delete []this->str;
        this->str = new char[other.size+1];
        strcpy(this->str,other.str);
        this->size = other.size;
        return *this;
    }
//    遍历函数
    void show ()
    {
        cout<<str<<endl;
        //cout<<"字符串长度为="<<size<<endl;
    }
//    判空函数
    void empty()
    {
        if(this->size==0)
        {
            cout<<"字符串为空"<<endl;
        }else{
            cout<<"字符串还剩余："<<str<<endl;
        }
    }
//    size函数（求实际长度）
    void mysize()
    {
        cout<<"字符串长度为： "<<strlen(this->str)<<endl;
    }
//    c_str函数
    char* myc_str(Mystring s1,char *p1)
    {
        strcpy(p1,s1.str);   // 将c++风格转换为c风格
        return p1;
    }
//    at函数（char &at（int pos））
    char Myat(int a)
    {
        if(a<0&&a>size)
        {
            cout<<"字符长度越界"<<endl;
            return -1;
        }
        char ch;
        return ch = *(str+a);
    }
//    加号运算符重载+
    const Mystring operator+(const Mystring &R1)
    {
        Mystring  L1;
        L1.str = strcat(this->str,R1.str);
        L1.size = this->size+R1.size;
        return L1;
    }
    //    加等于运算符重载+=
    Mystring & operator+= (const Mystring &R1)
    {
        Mystring s1;
        this->str = strcat(this->str,R1.str);
        this->size=this->size+R1.size;
        return *this;
    }
//    关系运算符重载
    bool operator>(const Mystring &R)const
    {
        if(strcmp(this->str,R.str)>0)
        {
            return true;
        }else{
            return false;
        }
    }
    bool operator>=(const Mystring &R)const
    {
        if(strcmp(this->str,R.str)>=0)
        {
            return true;
        }else{
            return false;
        }
    }
    //依次类推
    //清除内容
    Mystring &clear()
    {
        strcpy(this->str,"");
        this->size = 0;
        return *this;
    }
    //全局函数完成插入提取运算符重载
    friend ostream &operator<<( ostream &L,const Mystring &R);
    friend istream &operator>>(istream &L,const Mystring &R);
    //访问指定字符
    char operator[](int R)
    {
        return str[R];
    }
};

//全局函数完成插入运算符重载
ostream &operator<<( ostream &L,const Mystring &R)
{
    L<<R.str;
    return L;
}
//全局函数完成提取运算符重载
istream &operator>>(istream &L,const Mystring &R)
{
    L>>R.str;
    return L;
}
int main()
{
    Mystring s1="";
    Mystring s2="abcdefg";
    //验证拷贝构造函数
    Mystring s3(s2);
    //s2.show();
    //验证拷贝赋值函数
    s3.show();
    s3=s1;
    cout<<"拷贝";
    s3.show();
    //验证判空
    s2.empty();
    //验证大小
    s2.mysize();
    //验证c_str,c++字符串向c语言字符串转换
    char s4[20] = "kkkkkkk";
    char *p1 = s4;

    s1.myc_str(s2,p1);
    cout<<"p1 = "<<p1<<endl;
    //验证字符串 at函数
    cout<<s2.Myat(0)<<endl;
    //验证+运算符重载
    s3 = "111";
    s1 = s2 + s3;
    cout<<"s1 = ";
    s1.show();
    s1.mysize();
    //验证+=运算符重载
    s3+=s2;
    s2.show();
    s3.show();
    //验证关系运算符重载
    s1 = "c";
    s2 = "c";
    if(s1>s2)
    {
        cout<<"yes"<<endl;
    }else{
        cout<<"no"<<endl;
    }
    if(s1>=s2)
    {
        cout<<"yes"<<endl;
    }else{
        cout<<"no"<<endl;
    }
    cout<<"*********************************"<<endl;
    s1 = "abcde";
    s1.clear();
    s1.show();
    //验证插入运算符cout
    s1 = "shentingguang";
    cout<<s1<<endl;;

    //验证提取运算符cin
    cin>>s1;
    cout<<s1<<endl;
    //访问指定字符重载
    char C=s1[1];
    cout<<C<<endl;
    delete p1;

    return 0;
}

 3、思维导图