运算符实际上是一个函数,所以运算符的重载实际上是函数的重载,。编译程序对运算符的重载的选择,遵循函数重载的选择原则。当遇到不很明显的运算时,编译程序会寻找与参数相匹配的运算符函数。
1.重载运算符的必要性
C++语言中的数据类型分为基本数据类型和构造数据类型。基本数据类型可以直接完成算术运算。例如:
1
2
3
4
5
6
7
|
#include<bits/stdc++.h> using namespace std; int main( void ){ int a=10; int b=20; cout<<a+b<<endl; } |
程序中实现了两个整型变量的相加,可以正确输出运行结果30。通过两个浮点变量、两个双精度变量都可以直接运用加法运算符+来求和。但是类属于新构造的数据类型,类的两个对象就无法通过加法运算符来求和。例如:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
|
#include<bits/stdc++.h> using namespace std; class CBook{ public : CBook( int iPage){ m_iPage=iPage; } void display(){ cout<<m_iPage<<endl; } protected : int m_iPage; }; int main( void ){ CBook book1(10); CBook book2(20); tmp=book1+book2; //错误 tmp.display(); } |
当编译器编译到语句book1+book2时会报错,因为编译器不知道如何进行两个对象的相加,要实现两个类对象的加法运算有两种方法,一种是通过成员函数,一种是通过重载运算符。
首先看通过成员函数方法实现求和的例子:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
|
#include<bits/stdc++.h> using namespace std; class CBook{ public : CBook( int iPage){ m_iPage=iPage; } int add(CBook a){ return m_iPage+a.m_iPage; } void display(){ cout<<m_iPage<<endl; } protected : int m_iPage; }; int main( void ){ CBook book1(10); CBook book2(20); cout<<book1.add(book2)<<endl; } |
程序运行结果正确。使用成员函数实现求和的形式比较单一,并且不利于代码复用。如果要实现多个对象的累加其代码的可读性会大大降低,使用重载运算符的方法可以解决这些问题。
2.重载运算符的形式与规则
重载运算符的声明形式如下:
1
|
operator类型名(): |
operator是需要重载的运算符,整个语句没有返回类型,因为类型名就代表了它的返回类型。重载运算符将对象转化成类型名规定的类型,转换时的形式就像强制转换一样。但如果没有重载运算符定义,直接强制类型转换会导致编译器将无法通过编译。
重载运算符不可以是新创建的运算符,只能是C++语言中已有的运算符,可以重载的运算符如下:
算术运算符:+ - * / % ++ --
位操作运算符:& | ~ ^ >> <<
逻辑运算符 ! && ||
比较运算符 < > >= <= == !=
赋值运算符 = += -= *= /= %= &= |= ^= <<= >>=
其他运算符: [ ] () -> , new delete new[] delete[] ->*
并不是所有的C++语言中已有的运算符都可以重载,不允许重载的运算符有 . * :: ?和:
重载运算符时不能改变运算符操作数的个数,不能改变运算符原有的优先级,不能改变运算符原有的结合性,不能改变运算符原有的语法结构,即单目运算符只能重载为单目运算符,双目运算符只能重载为双目运算符,重载运算符含义必须清楚,不能有二义性。
实例:通过重载运算符实现求和:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
|
#include<bits/stdc++.h> using namespace std; class CBook{ public : CBook( int iPage){ m_iPage=iPage; } CBook operator+(CBook b) { return CBook(m_iPage+b.m_iPage); } void display(){ cout<<m_iPage<<endl; } protected : int m_iPage; }; int main( void ){ CBook book1(10); CBook book2(20); CBook tmp(0); tmp=book1+book2; tmp.display(); } |
类CBook重载了求和运算符后,由它声明的两个对象book1和book2可以向两个整型变量一样相加。
3.重载运算符的运算
重载运算符后可以完成对象和对象之间的运算,同样也可以通过重载运算实现对象和普通类型数据的运算。例如:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
|
#include<bits/stdc++.h> using namespace std; class CBook{ public : int m_Pages; void OutputPage(){ cout<<m_Pages<<endl; } CBook(){ m_Pages=0; } CBook operator+( const int page){ CBook book; book.m_Pages=m_Pages+page; return book; } }; int main( void ){ CBook Book1,Book2; Book2=Book1+10; Book2.OutputPage(); } |
通过修改运算符的参数为整数类型,可以实现CBook对象与整数相加。
对于两个整型变量的相加,可以调换加数和被加数的顺序,因为加法符合交换律。但是对于通过重载运算符实现的加法,不可以交换顺序。
illegal:
1
|
Book2=10+Book1; //非法代码 |
对于++和--运算符,由于涉及前置运算和后置运算,在重载这类运算符时如何区分呢?默认情况是,如果重载运算符没有参数则表示是前置运算,例如:
1
2
3
4
|
void operator++() //前置运算 { ++m_Pages; } |
如果重载运算符使用了整数作为参数,则表示的是后置运算,此时的参数值可以被忽略,它只是一个标识,标识后置运算。
1
2
3
4
|
void operator++( int ) //后置运算 { ++m_Pages; } |
默认情况下,将一个整数赋值给一个对象是非法的,可以通过重载运算符将其变成合法的。例如:
1
2
3
|
void operator = ( int page){ //重载运算符 m_Pages=page; } |
通过重载运算符也可以实现将一个整型数复制给一个对象,例如:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
|
#include<bits/stdc++.h> using namespace std; class CBook{ public : int m_Pages; void OutputPages() { cout<<m_Pages<<endl; } CBook( int page){ m_Pages=page; } operator = ( const int page){ m_Pages=page; } }; int main( void ){ CBook mybook(0); mybook = 100; mybook.OutputPages(); } |
程序中重载了赋值运算符,给mybook对象赋值100,并通过OutpuName()函数将其进行输出。
也可以通过重载构造函数将一个整数赋值给一个对象
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
|
#include<bits/stdc++.h> using namespace std; class CBook{ public : int m_Pages; void OutputPages() { cout<<m_Pages<<endl; } CBook(){ } CBook( int page){ m_Pages=page; } }; int main( void ){ CBook mybook; mybook = 100; mybook.OutputPages(); } |
程序中定义了一个重载的构造函数,以一个整数作为函数参数,这就可以将一个整数赋值给一个CBook类的对象,语句mybook=100;将调用构造函数CBook(int page)重新构造一个CBook对象,并将其赋值给mybook对象。
4.转义运算符
C++语言中普通的数据类型可以进行强制类型转换,例如:
1
2
3
|
int i=10; double d; d = double (i) |
程序中将整数i强制转换为double型。
语句
1
|
d= double (i) //等同于d=double(i) |
double()在C++语言中被转化为转换运算符。通过重载转换运算符可以将类对象转换为想要的数据。
实例:转换运算符
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
|
#include<bits/stdc++.h> using namespace std; class CBook{ public : CBook( double iPage=0); operator double (){ return m_iPage; } protected : int m_iPage; }; CBook::CBook( double iPage){ m_iPage = iPage; } int main( void ){ CBook book1(10.0); CBook book2(20.00); cout<< double (book1)+ double (book2)<<endl; } |
程序重载了转换运算符double(),然后将类CBook的两个对象强制转换为double类型后再进行求和,最后输出求和的结果。
总结
本篇文章就到这里了,希望能够给你带来帮助,也希望您能够多多关注服务器之家的更多内容!
原文链接:https://blog.csdn.net/Li5566123/article/details/123754077