C++操作符重载总结operator（小结 更新ing）

操作符重载一个原则是：被操作的数据类型中 至少有一个是自定义的类型（使用class定义类），如果被操作的变量都是基本类型，那么就不能定义操作符重载。

1.
如果重载了new,则必须重载delete,因为系统知道了你自定义了怎么new一个空间， 但是呢你使用delete的时候，系统并不知道怎么delete你所自定义申请的空间。
2.
类内定义与友元函数定义原则：

     对于二元操作符：二元操作符如果操作符左面是自定义类，那么直接在类里面实现重载函数即可；

     如果左边是标准变量（标准变量无法调用重载函数），右边是自定义类，那么就将重载函数设置为友元函数。重载函数在自定义类的外部定义实现。
3.

强制转化操作符重载：

　　ØC++不但允许重载运算操作符，还可以重载强制类型转换操作符，不过强制类型转换必须是C++基本数据类型之一，如int，float,char *等，强制类型转换注意以下几点：

　　Ø1、定义函数时不允许有参数，不允许有返回类型，但函数必须返回所需类型的值

　　Ø2、重载函数只可以是类成员函数，不可以为非类成员函数

operator int()//不能指定返回值
{
    return 整形变量;
}
operator int* ()
{
    return 整形变量地址;
}

最后放代码：（分析代码才是最快的捷径）

#include <iostream>
#include<string.h>
#include<stdlib.h>

using namespace std;
/*操作符重载一个原则是：被操作的数据类型，至少有一个是自定义的类型，
 * 如果被操作的变量都是基本类型，那么就不能定义操作符重载*/
class mystring
{
public:
    char *s;

    //一元操作符重载
    //重载1
    mystring operator=(const mystring &it)
    {   memset(s,0,1024);
        strcpy(s,it.s);
        return *this;
    }
    //重载2
    mystring operator+(const mystring &str)
    {
        strcat(s,str.s);
        return *this;
    }
    //重载3
    mystring operator + (const char *str)
    {
        strcat(s,str);
        return *this;
    }
    friend mystring operator + (const char *str,const mystring &it);

    //重载5
    mystring operator +=(const char *str)
    {
        strcat(s,str);
        return *this;
    }

    //重载6:<<作为简单的赋值操作
    void operator<<(const char *str)
    {
        strcpy(s,str);
    }

    //重载7:>>作为简单的赋值操作
    void operator>>(const char *str)
    {
        strcpy(str,s);
    }

    //重载8:new(必须有空格)
    /*如果重载了new,则必须重载delete,因为系统知道了你自定义了怎么new一个空间，
     * 但是呢你使用delete的时候，系统并不知道怎么delete你所自定义申请的空间。*/
    void * operator new(size_t size)
    {
        mystring *p =(mystring *)malloc(size);
        return p;
    }

    //重载9：delete
    void operator delete(void *obj)
    {
        //free(obj) //C:语言不能直接free一个void*类型，他不知道有多大内存要释放
        free((mystring*)obj);//使用强制类型转换
        obj=NULL;//防止野指针
    }

    //重载10：new[]
    void *operator new[](size_t size)//size总比实际分配空间大4个字节，存放一些系统内部的处理数据，也就是delete[]释放内存所需要的数据
    {
        mystring *p=(mystring *)malloc(size);
        return p;
    }
    //重载10；delete[]
    void operator delete[](void *obj)
    {
        free((mystring*)obj);
        obj=NULL;
    }

    //重载11：==（左边是自定义类，是一元重载）
    bool operator==(const mystring &it)
    {
        if(strcmp(s,it.s)==0)//判断二者的字符串是否相等。
            return true;
        else {
            return false;
        }
    }
    //设置友元函数
    friend bool operator==(const char* str,const mystring &it);
};


/*二元操作符：二元操作符如果操作符左面是类，那么直接在类里面实现重载函数即可，
如果左边是标准变量（标准变量无法调用重载函数）
右边是自定义类，那么就将重载函数设置为友元函数。
*/
//重载4
mystring operator + (const char *str,const mystring &it)
{
    char buf[1024]={0};
    mystring str1;
    sprintf(buf,"%s%s",str,it.s);
    strcpy(str1,buf);
    return str1;
}

//重载12：==（左边是一个普通的变量类型），定义二元重载函数，在类内部需要设置友元函数
bool operator==(const char* str,const mystring &it)
{
    if(strcmp(str,it.s)==0)
        return true;
    else {
        return false;
    }
}


int main()
{
    mystring str1;
    str1.s="hello";

    //使用重载1
    mystring str2 = str1;
    cout<<str2.s<<endl;

    //使用重载1,2
    mystring str3;
    mystring str4;
    str4.s=" C++";
    str3 = str2 + str4;
    cout<<str3.s<<endl;

    //使用操作符3
    mystring str5;
    str5.s="hello5 ";
    str5=str5+"c++5";
    cout<<str5.s<<endl;

    //使用重载8，9
    mystring *str6 = new mystring;
    delete str6;


    return 0;
}