第十一章 运算符重载

第十一章 运算符重载

1.  运算符重载

2.  在成员函数中实现自加

3.  重载前置自加运算符

返回类型 operator@（参数表）{}

@代表要重载的运算符

对象运算符重载不同于变量运算符重载

void operator++(){++n;}

++i;//等价于i.operator++();若i是变量 则++i就是调用operator++()

//n=++i;错误原因：右值为一个无符号的返回型

//1+2;等价于operator+(1+2),此时

4.  创建临时对象

见程序

5.  创建无名临时对象

返回含参构造函数

6.  取消创建临时对象

返回*this

7.  重载后置自加运算符

8.  重载加法运算函数operator+

11.  重载赋值运算函数operator=

10.  转换类型运算符

我们可以调用构造函数进行类型转换将一个变量赋给一个对象，但是反过来就不可以。（如果没有重载）

11.  重载限定

"."  "::"  "*"  "?:"  "#"   c++运算符除了这些不能被重载其他的都能被重载  

“.”成员选择运算符

“::”作用域限定运算符

“*”指针运算符

本章总结：

/**
成员数据为指针时 operator重载函数的定义
注意：当成员函数 不是常用变量 就要重新定义 运算符重载函数
*/


#include<iostream>
using namespace std;
class A
{
public:
    A(){n=new int;cout<<"执行无参构造函数
";}
    A(int i){n=new int;*n=i;cout<<"执行有参构造函数
";}
    A(A &r){n=new int;*n=*r.n;cout<<"执行复制构造函数
";}        //两块不同空间里的值相互复制
    ~A(){delete n;n=NULL;cout<<"执行析构函数
";}
    int get(){return *n;}
    void set(int x){*n=x;}

    //A &operator++(){++n;return *this;}
    A &operator++(){++(*n);return *this;}//前置自加//this是全局变量按别名返回可以避免调用复制构造函数

    //A operator++(int o){A temp(n);++n;return temp;}
    A operator++(int o){A temp(*n);++(*n);return temp;}//后置自加//这个要调用复制构造函数

    //A operator+(A &r){return A(n+r.n);}
    A operator+(A &r){return A(*n+*r.n);}//object1.operator+(object2)不会调用复制构造函数，只会调用构造函数创建一个临时的对象

    //A operator-(A &r){return A(n-r.n);}
    A operator-(A &r){return A(*n-(*(r.n)));}

    //A operator*(A &r){return A(n*r.n));}
    A operator*(A &r){return A(*n*(*(r.n)));}

    //A operator/(A &r){return A(n/r.n);}
    A operator/(A &r){return A(*n/(*(r.n)));}

    A &operator=(A &r)
    {
        if(this==&r)
            return *this;        
        else
            *(this->n)=*(r.n);
        return *this;
    }
private:
    int *n;        //指针就像一把万能钥匙，要想利用这把钥匙就必须要有对应的空间
};
int main()
{
    A a(1);
    A b(3);
    A c(5);
    A x;
    ++a;//a.operator++()
    cout<<a.get()<<endl;
    x=a++;
    cout<<x.get()<<endl;
    cout<<a.get()<<endl;
    a=b+c;//a.operator=(b.operator+(c))//这里优化了，不再调用复制构造函数
    cout<<a.get()<<endl;
    a=b-c;
    cout<<a.get()<<endl;
    a=b*c;
    cout<<a.get()<<endl;
    a=b/c;
    cout<<a.get()<<endl;

    return 0;
}




///**
//利用operator进行类型转换
//我们可以调用构造函数进行类型转换将一个变量赋给一个对象，但是反过来就不可以。（如果没有重载）
//*/
//
//#include<iostream>
//using namespace std;
//class A
//{
//public:
//    A(){cout<<"执行无参构造函数
";}
//    A(double i){n=i;cout<<"执行含参构造函数
";}
//    A(A &r){cout<<"执行复制构造函数
";}
//    ~A(){cout<<"执行析构函数
";}
//    int get(){return n;}
//    void set(int x){n=x;}
//    operator double(){return n;}//没有返回类型但可以有返回值；没有参数但可以传参
//private:
//    double n;
//};
//int main()
//{
//    A object1(9.9);
//    cout<<double(object1)<<endl;//显示转换
//    cout<<(object1)<<" "<<object1<<endl;//隐式转换
//    double x;
//    x=object1;
//    cout<<x<<endl;//隐式转换
//    return 0;
//}