嵌入式学习22（C++重载运算符 上）

1、 引入：运算符只能识别基本类型（整型，浮点型，字符类型），不能识别复杂类型
特点：

• 重载运算符时，不会改变运算的顺序。（操作数与被操作的顺序不会改变）
• 不会改变结合性。
• 不会改变运算的优先级（与C语言中运算符优先一致） 1+2+3+4 ia+ib+ic+id不会改运算符的特性。
• 如下运算是不能重载的： . -> sizoef :: ? ： （已经在C++/C语言中明确作用）

2、知识储备：
友元函数：当某个函数需要访问某类的非公有成员（方法、属性）时，由于类的封装性，在类外不能访问可以将此函数声明为此类的类友函数时。函数在类外访问类所有信息。
注：优点：友元可以通过声明友元时，此函数访问所有成员
缺点：破坏封装性。

(+ - * /)返回一个新对象
(> < ==)返回bool
(<< )返回为了连续输出output

#include<iostream>
#include<string.h>
using namespace std;

class mystring
{
public:
        mystring();
        mystring(const char*);
        mystring(mystring&);
        ~mystring();
        bool operator>(mystring& s);
        bool operator<(mystring& s);
        bool operator==(mystring& s);
        mystring& operator+(mystring& s);
        char operator[](int);
        friend ostream& operator<<(ostream& output,mystring& s);
private:
        char *buf;
};
mystring::mystring():buf(NULL){}
mystring::mystring(const char* s)
{
    buf=new char[strlen(s)+1];
    memcpy(buf,s,strlen(s)+1);
}
mystring::mystring(mystring& s)
{   
/*  buf=new char[sizeof(s.buf)];  //sizeof(指针）永远为4啊！！
    memcpy(buf,s.buf,sizeof(s.buf)); */
    buf=new char[strlen(s.buf)+1];
    memcpy(buf,s.buf,strlen(s.buf)+1);
}
mystring::~mystring()
{
    delete this->buf;
}
ostream& operator<<(ostream& output,mystring& s)
{
    int i;
    for(i=0;i<strlen(s.buf);i++)
            output<<s.buf[i];
    output<<endl;
    return output;
}
bool mystring::operator>(mystring& s)
{
    if(strcmp(this->buf,s.buf)>0)
            return true;
    return false;
}
bool mystring::operator<(mystring& s)
{
    if(strcmp(this->buf,s.buf)<0)
            return true;
    return false;
}
bool mystring::operator==(mystring& s)
{
    if(strcmp(this->buf,s.buf)==0)
            return true;
    return false;
}
mystring&  mystring::operator+(mystring& s)//得返回引用，不然和构造函数冲突
{                                          //返回引用意味着不能连加
    static mystring obj;//局部空间用完就释放了
    obj.buf=new char[strlen(buf)+strlen(s.buf)+1];//先有空间再拷贝
    memcpy(obj.buf,this->buf,strlen(this->buf));
    memcpy(obj.buf+strlen(this->buf),s.buf,strlen(s.buf)+1);
    return obj;
}
char mystring::operator[](int index)
{
    if(index>strlen(this->buf)-1)
    {
        cout<<"下标超出"<<endl;
        return 0;
    }
    return this->buf[index];
}


int main()
{
    mystring a("hello");
    mystring b=a;

    mystring c("cmz");
    mystring d=a+c;
    cout<<d[0];
    return 0;
}