C++编程思想 12章运算符重载_c++中integer和this-CSDN博客

本文链接：https://blog.csdn.net/seektostart/article/details/9412957

12.1

两个极端

有些人容易滥用运算符重载。但应该注意他仅仅只是一种语法上的方便，是另外一种调用函数的方式而已。

意义：能使涉及类的代码更易写。

局限：只有那些包含用户自定义类型的表达式才能有使用重载的运算符。

12.2

定义重载的运算就像定义函数，只是该函数的名字是operator@ ,这里@代表被重载的运算符

函数参数表中参数的个数取决于两个因素

1）运算符是一元的（一个参数）还是二元的（2个参数）。

2）运算符被定义为全局函数.

例如

    C++ Code  
 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41

#include <iostream>
using namespace std;

class Integer
{
     int i;
public :
    Integer( int ii):i(ii){}
     const Integer //返回值
     operator +( const Integer& rv) const
    {
        cout<< "operator+" <<endl;
         return (Integer(rv.i+i));
    }
    Integer&
     operator +=( const Integer& rv)
    {
        cout<< "operator+=" <<endl;
        i+=rv.i;
         return * this ;
    }
     friend void print( const Integer& rv);

};
void print( const Integer& rv)
{
    cout<<rv.i;
}
void main( void )
{
    cout<< "built_in types:" <<endl;
     int i = 1 ,j  = 2 ,k= 3 ;
    k+=i+j;
    cout<< "user-defined types:" <<endl;
    Integer ii( 1 ),jj( 2 ),kk( 3 );
    kk+=ii+jj;
    print(kk);
    system( "pause" );

}

这个两个重载运算符被定义为内敛函数，在他们调用的时候就会显示调用信息，对于二元运算符，唯一的参数是出现在运算符右侧那个操作数，当一元运算符没有参数，所调用的成员函数属于运算符左侧的那个对象。

    C++ Code  
 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130

#include <iostream>
using namespace std;
class Integer
{
     long i;
    Integer* This(){ return this ;}
public :
    Integer( long ll= 0 ):i(ll){}
     friend const Integer&
         operator +( const Integer& a);
     friend const Integer
         operator -( const Integer& a);
     friend const Integer
         operator ~( const Integer& a);
     friend const Integer*
         operator &(Integer& a);
     friend const Integer
         operator ++(Integer& a);
     friend const Integer
         operator ++(Integer& a, int );
     friend const Integer&
         operator --(Integer& a);
     friend const Integer
         operator --(Integer&a , int )
};

const Integer& operator +( const Integer& a)
{
    cout<< "+Integer" <<endl;
     return a;
}
const Integer operator -( const Integer& a)
{
    cout<< "+Integer \n" ;
     return Integer(-a.i);
}
const Integer operator ~( const Integer& a)
{
    cout<< "~Integer\n" <<endl;
     return Integer(~a.i);
}
Integer* operator &(Integer& a)
{
    cout<< "&Integer" <<endl;
     return a.This();
}
int operator !( const Integer& a)
{
    cout<< "!Integer" <<endl;
     return !a.i;
}
const Integer& operator ++(Integer& a)
{
    cout<< "++Integer" <<endl;
    a.i++;
     return a;
}
const Integer operator ++(Integer& a, int )
{
    cout<< "Integer++" <<endl;
    Integer before(a,i);
    a.i++;
     return before;
}
const Integer& operator --(Integer& a)
{
    out<< "Interger--" <<endl;
    a.i--;
     return a;

}
const Integer operator --(Integer& a, int )
{
    out<< "Interger--" <<endl;
    Integer before(a,i);
    a.i--;
     return before;
}

void f(Integer a )
{
    +a;
    -a;
    ~a;
    Integer* io = &a;
    ! a;
    ++a;
    a++;
    --a;
    a--;

}

class Byte
{
     unsigned char b;
    Byte( unsigned char bb = 0 ) b(bb){}
     const Byte& operator +() const
    {
        cout<< "+byte\n" ;
         return * this ;
    }
     const Byte operator ~() const
    {
        cout<< "-Byte" <<endl;
         return Byte(~b);
    }
     const Byte operator -() const
    {
        cout<< "-byte" <<endl;
         return Byte(-b);
    }
     const operator !() const
    {
        cout<< "!Byte" <<endl;
         return Byte(!b);

    }
    Byte* operator &()
    {
        cout<< "&Byte" <<endl;
         return this ;
    }
     const Byte operator ++()
    {
        cout<< "++byte" <<endl;
        b++;
         return * this ;
    }
};

12.3可重载的运算符

虽然几乎所有的C中的运算符都可以重载，但运算符重载的使用是相当受限制的，例如不能使用C中没有意义的。

不能改变运算符的优先级，不能改变运算符的参数个数

12.3.1 自增和自减

重载的++ 和--运算符有点然人进退维谷，因为我们总是希望能根据他们出现的所作用的前面，还是后面，

解决的方法很简单

例如当编译器看到++a的时候，他就调用operator++（a）;

但当编译器看到a++的时候，他就调用operator++（a，int）。即编译器通过调用不同的重载函数区别这两种形式