技术总结:
运算符重载,目的就是让自定义的类可以使用 运算符。
具体运算操作,写在重载的运算符操作内。
前置资料
运算符重载
要重载运算符,需使用被称为运算符函数的特殊函数形式。运算符函数的格式如下:
示例 | 解析 |
---|---|
operatorop(argument-list) | operator + 运算符 + (参数列表) |
operator+( ) | 重载+运算符 |
operator*( ) | 重载*运算符 |
operator-( ) | 重载-运算符 |
重载限制:
- op必须是有效的C++运算符,不能虚构一个新的符号。
- 重载后的运算符必须至少有一个操作数是用户定义的类型,这将防止用户为标准类型重载运算符。(一定其中一个是自定义类,一般都是自定义类运算符重载)
- 使用运算符时不能违反运算符原来的句法规则。(比如运算符通常是要两个操作数a+b 之类)
- 不能修改运算符的优先级。(运算优先级与原先一致)
- 不能重载下面的运算符
运算符 | 解析 |
---|---|
sizeof | sizeof运算符 |
. | 成员运算符 |
. * | 成员指针运算符 |
:: | 作用域解析运算符 |
?: | 条件运算符 |
typeid | 一个RTTI运算符 |
const_cast | 强制类型转换运算符 |
dynamic_cast | 强制类型转换运算符 |
reinterpret_cast | 强制类型转换运算符 |
static_cast | 强制类型转换运算符 |
- 大多数运算符都可以通过成员或非成员函数进行重
载,但下面的运算符只能通过成员函数进行重载。
运算符 | 解析 |
---|---|
= | 赋值运算符 |
( ) | 函数调用运算符 |
[ ] | 下标运算符 |
-> | 通过指针访问类成员的运算符 |
- 其他可重载运算符
+ | - | * | / | % | ^ |
& | | | ~= | ! | = | < |
> | += | -= | *= | /= | %= |
^= | &= | |= | << | >> | >>= |
<<= | == | != | <= | >= | && |
|| | ++ | - - | , | ->* | -> |
( ) | [ ] | new | delete | new[ ] | delete[ ] |
友元函数
关键字:friend
在一个类中,使用关键字 friend + 函数,即可让函数成为类的友元函数。
特性
C++ 提供的外部对类的private成员的访问方式
通过让函数成为类的友元,可以赋予该函数与类的成员函数相同的访问权限。
友元家族
- 友元函数
- 友元类
- 友元成员函数
实例解析
Time.h
#include <iostream>
class Time{
private:
int hours;
int minutes;
public:
Time();
Time(int h, int m = 0);
Time operator*(const int n); #1
friend Time operator+(const Time &t1, const Time &t2);
friend Time operator-(const Time &t1, const Time &t2);
friend Time operator*(const double n, const Time &t1); #2
friend std::ostream& operator<<(std::ostream &os, const Time &t);
};
Time.cpp
int hours;
int minutes;
Time::Time(void)
{
hours = 0;
minutes = 0;
}
Time::Time(int h, int m)
{
hours = h;
minutes = m;
}
Time Time::operator*(const int n)
{
hours = hours * n + (minutes * n) / 60;
minutes = (minutes * n) % 60;
return *this;
}
//下面开始是友元函数
Time operator+(const Time &t1, const Time &t2) #3
{
Time t3;
t3.minutes = t1.minutes + t2.minutes;
t3.hours = t1.hours + t2.hours + t3.minutes / 60;
t3.minutes = t3.minutes % 60;
return t3;
}
Time operator-(const Time &t1, const Time &t2)
{
Time diff;
int tot1, tot2;
tot1 = t1.hours * 60 + t1.minutes;
tot2 = t2.hours * 60 + t2.minutes;
diff.hours = (tot1 - tot2) / 60;
diff.minutes = (tot1 - tot2) % 60;
return diff;
}
Time operator*(const double n, const Time &t1)
{
Time result;
long totalminutes = t1.hours * n * 60 + t1.minutes * n;
result.hours = totalminutes / 60;
result.minutes = totalminutes % 60;
return result;
}
std::ostream& operator<<(std::ostream &os, const Time &t)
{
os << t.hours << " hours, " << t.minutes << " minutes";
return os;
}
main.cpp 调用输出
int main(void)
{
Time aida(3, 35);
Time tosca(2, 48);
Time temp;
cout << "Aida and Tosca:\n";
cout << aida << "; " << tosca << endl;
temp = aida + tosca;
cout << "Aida + Tosca: " << temp << endl;
temp = aida*1.17; #4
cout << "Aida* 1.17: " << temp << endl;
cout << "10.0 * Tosca: " << 10.0 * tosca << endl; #5
}
输出为:
Aida and Tosca:
3 hours, 35 minutes; 2 hours, 48 minutes
Aida + Tosca: 6 hours, 23 minutes
Aida* 1.17: 3 hours, 35 minutes
10.0 * Tosca: 28 hours, 0 minutes
解析
-
#1 Timer重载了 * 运算符。 若使用Timer * n 格式的运算,均会调用该重载运算符。
-
#2 Timer利用友元重载了 * 运算符, 若使用了 n * Timer 格式的运算,均会调用该重载运算符。
-
#3 友元函数的基本操作,它首先是普通函数。所以定义实现不需要加关键字friend, 只需要在使用的类中,加上关键字friend即可。
-
Timer * n 与 n * Timer的不同:
以下运算: -
#4: 对 aida*1.17 而言,默认类本身为第一参数,所以只需重载Timer * n
-
#5 :而对于 10.0 * tosca , 第一运算符是n,因此无法匹配,需要有 n * Timer运算符的重载。