7.20 C++

1.思维导图

运算符的重载

 静态成员

继承 

String类型函数与运算符重载 

#include 
#include

using namespace std;
class My_string
{
private:
    char *str;  //字符串
    int size;  //字符串大小
public:
    //无参构造
    My_string():size(50)
    {
        str = new char[size];    //构造出一个长度为10的字符串
        strcpy(str,"");         //赋值为空串
    }
    //有参构造
    My_string(const char* s)
    {
        size=strlen(s);
        str=new char[size+1];
        strcpy(str,s);
    }
    //析构函数
    ~My_string()
    {
        delete str;
        str=nullptr;
    }
    //拷贝构造函数
    My_string(const My_string& other):str(new char[other.size+1]),size(other.size)
    {
        strcpy(this->str,other.str);
    }
    //拷贝赋值函数
    My_string& operator=(const My_string &other)
    {
        if(this!=&other)
        {
            delete this->str;
            this->size=other.size;
            this->str=new char[size+1];
            strcpy(this->str,other.str);
        }
        return *this;
    }

    //运算符重载
    //加号"+"运算符重载
    const My_string operator+(const My_string &dest)const
    {
        My_string temp;
        strcpy(temp.str,strcat(this->str,dest.str));
        return temp;
    }
    //加等于"+="运算符重载
    My_string& operator+=(const My_string &dest)
    {
        strcat(this->str,dest.str);
        return *this;
    }
    //关系">"运算符重载
    bool operator>(My_string &S)
    {
        if(strcmp(this->str,S.str)>0)
            return true;
        else
            return false;
    }
    //关系"<"运算符重载
    bool operator<(My_string &S)
    {
        if(strcmp(this->str,S.str)<0)
            return true;
        else
            return false;
    }
    //关系"=="运算符重载
    bool operator==(My_string &S)
    {
        if(strcmp(this->str,S.str)==0)
            return true;
        else
            return false;
    }
    //"!="运算符重载
    bool operator!=(My_string &S)
    {
        if(strcmp(this->str,S.str)!=0)
            return true;
        else
            return false;
    }
    //成员函数版实现中括号"[]"运算符
    char& operator[](const int index)
    {
           return str[index];
    }

    //全局函数版完成插入"<<"运算符重载函数
    friend ostream &operator<<(ostream &os,const My_string &S);
    //全局函数版完成提取">>"运算符重载函数
    friend istream &operator>>(istream &is,const My_string &S);
    //输出函数
    void Output();
    //判空函数声明
    bool Isempty();
    //字符串长度大小
    int Strlen();
    //返回地址
    char* C_str();
    //获取字符
    char &At(int pos);



};

//判空函数
bool My_string::Isempty()
{
    return this->str==0?true:false;
}

//Strlen()函数
int My_string::Strlen()
{
    if(Isempty())
        return false;
    return strlen(str);

}

//输出函数
void My_string::Output()
{
    if(Isempty())
        return;
    cout<str<size)
        return str[pos];
    else
        cout<<"下标越界!"<>(cin)
istream &operator>>(istream &is,const My_string &S)
{
    is>>S.str;
    return is;
}
int main()
{
    //有参构造
    My_string s1("he");
    cout<<"s1=";
    s1.Output();

    My_string s2;  //无参构造
    s2=s1;  //拷贝赋值
    cout<<"s2=";
    s2.Output();

    My_string s3(s2);  //拷贝构造
    s3=s2+"llo";  //重载"+"运算符
    cout<<"s3=";
    s3.Output();

    s3+=",China!";  //重载"+="运算符
    cout<<"s3=";
    s3.Output();

    if(s3>s2)
        cout<<"s3>s2"<"运算符
    else if(s3>n;
    cout<