常用的重载运算符你了解几个？

知识点介绍
运算符重载，就是对已有的运算符重新进行定义，赋予其另一种功能，以适应不同的数据类型运算符重载的目的：简化操作 让已有的运算符 适应适应不同的数据类型。
简单的介绍一下，接下来酒肉伺候~
由于比较多，故分文件来实现
mystring.h


#ifndef MYSTRING_H
#define MYSTRING_H
#include


using namespace std;


class myString
{
//重载<<运算符
    friend ostream &operator <<(ostream &out,myString &ob);
    //重载>>运算符
    friend istream &operator >>(istream &in,myString &ob);
private:
    char *str;
    int size;
public:
    myString();//无参构造函数
    myString(char *str);//有参构造函数
    myString(const myString &ob);//拷贝构造函数
    ~myString();//析构函数
    int size1(void);//返回size大小
    //重载[]运算符
    char &operator [](int index);
    //重载=运算符
    myString &operator =(const myString &ob);
    //实现对象和字符串的直接=运算
    myString &operator =(const char *str);
    //重载+运算符
    myString &operator +(const myString &ob);
     //实现对象和字符串的直接+运算
    myString &operator +(const char *str);
    //重载==运算符
    bool operator ==(const myString &ob);
     //实现对象和字符串的直接==运算英镑符号
    bool operator ==(const char *str);
};




#endif // MYSTRING_H



mystring.cpp


#include "mystring.h"
#include
#include




using namespace std;






//无参构造函数
myString::myString()
{
    str=NULL;
    size=0;
    cout<<"无参构造"<
}


//有参构造函数
myString::myString(char *str)
{
    cout<<"有参构造"<
    this->str=new char [strlen(str)+1];
    strcpy(this->str,str);




    size=strlen(str);
}


//拷贝构造函数
myString::myString(const myString &ob)
{
//清空str的原有内容，防止内存泄漏
    if(this->str!=NULL)
    {
        delete [] str;
        this->str=NULL;
    }
    this->str=new char [strlen(ob.str)+1];
    strcpy(this->str,ob.str);




    size=ob.size;




}


//析构函数
myString::~myString()
{
    if(str!=NULL)
    {
        delete [] str;
        this->str=NULL;
    }
}


//返回size大小
int myString::size1()
{
    return size;
}


//重载[]运算符
char &myString::operator [](int index)
{
//判断size大小是否合理
    if(index>0 && index
    {
        return str[index];
    }




    else
    {
        cout<<"无效的index"<
    }
}


/重载=运算符
myString &myString::operator =(const myString &ob)
{
//清空str的原有内容，防止内存泄漏
    if(str!=NULL)
    {
        delete [] str;
        str=NULL;
    }




    str=new char[ob.size+1];
    strcpy(str,ob.str);




    size=ob.size;
    return *this;//返回当前引用对象




}


//实现对象和字符串的直接=运算
myString &myString::operator =(const char *str)
{
    if(this->str!=NULL)
    {
        delete [] this->str;
        this->str=NULL;
    }




    this->str=new char[strlen(str)+1];
    strcpy(this->str,str);




    size=strlen(str);
    return *this;
}


//重载+运算符
myString & myString::operator +(const myString &ob)
{
    char* tmp_str=new char[ob.size+size+1];
    memset(tmp_str,0,ob.size+size+1);
    strcpy(tmp_str,str);
    strcat(tmp_str,ob.str);


//tmp为局部变量，仅在当前大括号有效，加static使其成为静态局部变量 防止其释放
    static myString tmp(tmp_str);
    return tmp;
}


//实现对象和字符串的直接+运算
myString &myString::operator +(const char *str)
{
    char* tmp_str=new char[strlen(str)+size+1];
    memset(tmp_str,0,strlen(str)+size+1);
    strcpy(tmp_str,this->str);
    strcat(tmp_str,str);




    static myString tmp(tmp_str);
    return tmp;
}


//重载==运算符
//返回值bool类型，if判断语句需要
bool myString::operator ==(const myString &ob)
{
    if(strcmp(str,ob.str)==0)
        return true;
    else
        return false;
}


//实现对象和字符串的直接+运算
bool myString::operator ==(const char *str)
{
    if(strcmp(this->str,str)==0)
        return true;
    else
        return false;
}


//重载<<运算符
ostream &operator <<(ostream &out, myString &ob)
{
    out<
    return out;
}


//重载>>运算符
istream &operator >>(istream &in,myString &ob)
{
    cout<<"请输入要输入的字符串：";
    if(ob.str!=NULL)
    {
        delete [] ob.str;
        ob.str=NULL;
    }




    char buf[1024];
    in>>buf;
    ob.str=new char[strlen(buf)+1];
    strcpy(ob.str,buf);
    ob.size=strlen(buf);




    return in;
}

main.cpp


#include
#include




using namespace std;




int main(int argc, char *argv[])
{
    myString ob1("lucy");
    cout<
    cout<<"size="<




    cin>>ob1;
    cout<
    cout<<"size="<
    ob1[1]='E';
    cout<




    myString ob2=ob1;
    cout<
    cout<<"size="<




    myString ob3=ob2;
    cout<
    cout<<"size="<
    myString ob4="hello ob4";
    cout<
    cout<<"size="<




    myString ob5("我爱美女");
    myString ob6("美女爱我");
    cout<
    cout<




    myString ob7("hehe");
    myString ob8("haha");
    if(ob7==ob8)
    {
        cout<<"相等"<
    }
    else
    {
        cout<<"不相等"<
    }




    if(ob7=="hehe")
    {
        cout<<"相等"<
    }
    else
    {
        cout<<"不相等"<
    }




    return 0;
}