首页 > 其他 > 详细

第十一章 运算符重载

时间:2014-05-19 16:59:43      阅读:489      评论:0      收藏:0      [点我收藏+]

第十一章 运算符重载

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.  重载后置自加运算符

 bubuko.com,布布扣

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

bubuko.com,布布扣 

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

10.  转换类型运算符

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

 bubuko.com,布布扣 

11.  重载限定

 bubuko.com,布布扣

“.”成员选择运算符

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

“*”指针运算符

本章总结:

 

bubuko.com,布布扣
  1 /**
  2 成员数据为非指针时 operator重载函数的定义
  3 */
  4 
  5 //#include"iostream"
  6 //using namespace std;
  7 //class A
  8 //{
  9 //public:
 10 //    A(){cout<<"执行无参构造函数\n";}
 11 //    A(int a){this->n=a;cout<<"执行带参构造函数"<<n<<endl;}
 12 //    A(A &r){n=r.n;cout<<"执行复制构造函数\n";}
 13 //    ~A(){cout<<"执行析构函数\n";}
 14 //    int get(){return n;}
 15 //    void set(int x){n=x;}
 16 //        
 17 //    A &operator++(){cout<<"执行++operator"<<endl;n++;return *this;}//用this时要调用复制构造函数,又因为this是全局变量,
 18 //    //所以可以设为按别名返回,避免调用复制构造函数
 19 //    //A operator++(){cout<<"执行++operator"<<endl;++n;A num(n);return num;}//这个要调用复制构造函数
 20 //    
 21 //    A operator++(int o){cout<<"执行operator++"<<endl;A num(n);n++;return num;}
 22 //    
 23 //    A operator+(A &r){cout<<"执行operator+"<<endl;return A(n+r.n);}//object1.operator+(object2)不会调用复制构造函数,
 24 //    //只会调用构造函数创建一个临时的对象
 25 //    
 26 //    A operator-(A &r){return A(n-r.n);}
 27 //    
 28 //    A operator*(A &r){return A(n*r.n);}
 29 //    
 30 //    A operator/(A &r){return A(n/r.n);}
 31 //    
 32 //    A &operator=(A &r)
 33 //    {
 34 //        cout<<"执行operator="<<endl;
 35 //        if(this==&r)        //判断启调对象与被调对象是否为同一个地址
 36 //            return *this;
 37 //        else
 38 //            this->n=r.n;
 39 //        return *this;
 40 //    }
 41 //private:
 42 //    int n;
 43 //
 44 //};
 45 //int main()
 46 //{
 47 //    A object1(1);
 48 //    A object2(2);
 49 //    A object3;
 50 //    object3=object1+object2;//这里优化了,不再调用复制构造函数
 51 //    cout<<object3.get()<<endl;
 52 //    A x(9);
 53 //    x=object3++;
 54 //    x=++object3;
 55 //    cout<<x.get()<<endl;
 56 //    cout<<object3.get()<<endl;
 57 //    return 0;
 58 //}
 59 
 60 
 61 
 62 /**
 63 成员数据为指针时 operator重载函数的定义
 64 注意:当成员函数 不是常用变量 就要重新定义 运算符重载函数
 65 */
 66 
 67 
 68 //#include<iostream>
 69 //using namespace std;
 70 //class A
 71 //{
 72 //public:
 73 //    A(){n=new int;cout<<"执行无参构造函数\n";}
 74 //    A(int i){n=new int;*n=i;cout<<"执行有参构造函数\n";}
 75 //    A(A &r){n=new int;*n=*r.n;cout<<"执行复制构造函数\n";}        //两块不同空间里的值相互复制
 76 //    ~A(){delete n;n=NULL;cout<<"执行析构函数\n";}
 77 //    int get(){return *n;}
 78 //    void set(int x){*n=x;}
 79 //    //A &operator++(){++n;return *this;}
 80 //    A &operator++(){++(*n);return *this;}
 81 //    //A operator++(int o){A temp(n);++n;return temp;}
 82 //    A operator++(int o){A temp(*n);++(*n);return temp;}
 83 //    //A operator+(A &r){return A(n+r.n);}
 84 //    A operator+(A &r){return A(*n+*r.n);}
 85 //    //A operator-(A &r){return A(n-r.n);}
 86 //    A operator-(A &r){return A(*n-(*(r.n)));}
 87 //    //A operator*(A &r){return A(n*r.n));}
 88 //    A operator*(A &r){return A(*n*(*(r.n)));}
 89 //    //A operator/(A &r){return A(n/r.n);}
 90 //    A operator/(A &r){return A(*n/(*(r.n)));}
 91 //    A &operator=(A &r)
 92 //    {
 93 //        if(this==&r)
 94 //            return *this;        
 95 //        else
 96 //            *(this->n)=*(r.n);
 97 //        return *this;
 98 //    }
 99 //private:
100 //    int *n;        //指针就像一把万能钥匙,要想利用这把钥匙就必须要有对应的空间
101 //};
102 //int main()
103 //{
104 //    A a(1);
105 //    A b(3);
106 //    A c(5);
107 //    A x;
108 //    ++a;
109 //    cout<<a.get()<<endl;
110 //    x=a++;
111 //    cout<<x.get()<<endl;
112 //    cout<<a.get()<<endl;
113 //    a=b+c;
114 //    cout<<a.get()<<endl;
115 //    a=b-c;
116 //    cout<<a.get()<<endl;
117 //    a=b*c;
118 //    cout<<a.get()<<endl;
119 //    a=b/c;
120 //    cout<<a.get()<<endl;
121 //
122 //    return 0;
123 //}
124 
125 
126 
127 
128 /**
129 利用operator进行类型转换
130 我们可以调用构造函数进行类型转换将一个变量赋给一个对象,但是反过来就不可以。(如果没有重载)
131 */
132 
133 #include<iostream>
134 using namespace std;
135 class A
136 {
137 public:
138     A(){cout<<"执行无参构造函数\n";}
139     A(double i){n=i;cout<<"执行含参构造函数\n";}
140     A(A &r){cout<<"执行复制构造函数\n";}
141     ~A(){cout<<"执行析构函数\n";}
142     int get(){return n;}
143     void set(int x){n=x;}
144     operator double(){return n;}//没有返回类型但可以有返回值;没有参数但可以传参
145 private:
146     double n;
147 };
148 int main()
149 {
150     A object1(9.9);
151     cout<<double(object1)<<endl;//显示转换
152     cout<<(object1)<<" "<<object1<<endl;//隐式转换
153     double x;
154     x=object1;
155     cout<<x<<endl;//隐式转换
156     return 0;
157 }
bubuko.com,布布扣

 

第十一章 运算符重载,布布扣,bubuko.com

第十一章 运算符重载

原文:http://www.cnblogs.com/zenseven/p/3735003.html

(0)
(0)
   
举报
评论 一句话评论(0
关于我们 - 联系我们 - 留言反馈 - 联系我们:wmxa8@hotmail.com
© 2014 bubuko.com 版权所有
打开技术之扣,分享程序人生!