一,操作符重载
1)函数重载(多态)
名称相同,特征标(参数列表)不同的函数。完成相同的基本操作
2)操作符左侧的对像是调用对象,操作符右侧的作为参数被传递的对象
3)重载限制:1>重载后的操作符至少有一个操作数是用户定义的类型。防止用户为标准类型重载操作符
2>使用操作符,不能违反操作符原来的句法规则。
3>不能修改操作符优先级,不能定义新的操作符
4>可被重载的操作符:
+ - * / % ^ & | ~
! = < > + = -= *= /= %=
^= &= | =<< >> > >= << == = !=
<= >= && || ++ -- [ ] ( ) ->
->* , new new[ ] delete delete[ ]
4)不要返回局部变量的引用,因为函数执行完毕后,局部变量将会消失
二,操作符重载示例
#include <iostream>
class Time
{
private:
int hours;
int minutes;
public:
Time();
Time(int h,int m=0);
void addmin(int m);
void addhr(int h);
void reset(int h=0,int m=0);
Time operator+ (const Time &t)const;
Time operator- (const Time &t)const;
Time operator* (double mult)const;
void show()const;
};
Time::Time()
{
hours=minutes=0;
}
Time::Time(int h, int m)
{
hours=h;
minutes=m;
}
void Time::addhr(int h)
{
hours=hours+h;
}
void Time::addmin(int m)
{
minutes=minutes+m;
hours=minutes/60;
minutes=minutes%60;
}
void Time::reset(int h, int m)
{
hours=h;
minutes=m;
}
Time Time::operator +(const Time& t) const
{
Time sum;
sum.minutes=minutes+t.minutes;
sum.hours=hours+t.hours+sum.minutes/60;
sum.minutes=sum.minutes%60;
return sum;
}
Time Time::operator -(const Time& t) const
{
Time diff;
int tot1,tot2;
tot1=minutes+60*hours;
tot2=t.minutes+60*t.hours;
diff.minutes=(tot1-tot2)%60;
diff.hours=(tot1-tot2)/60;
return diff;
}
Time Time::operator *(double mult) const
{
Time result;
long totalminutes = hours*mult*60+minutes*mult;
result.hours=totalminutes/60;
result.minutes=totalminutes%60;
return result;
}
void Time::show() const
{
std::cout<<hours<<" hours "<<minutes<<" minutes "<<std::endl;
}
int main()
{
using std::cout;
using std::endl;
Time weeding(4,35);
Time waxing(2,27);
Time total;
Time diff;
Time adjusted;
cout<<"weeding Time = ";
weeding.show();
cout<<endl;
cout<<"waxing Time = ";
waxing.show();
cout<<endl;
cout<<"total work Time=";
total=weeding + waxing;
total.show();
cout<<endl;
diff=weeding -waxing;
cout<<"weeding - waxing =";
diff.show();
cout<<endl;
adjusted=total*1.5;
cout<<"adjusted work Time =";
adjusted.show();
cout<<endl;
return 0;
}
程序注意事项:1>不能使用关键字 time作为类名
2>操作符重载total = weeding + waxing;执行为: weeding.operator+(waxing),然后返回一个Time对象
3>将参数声明为引用的目的:提高效率
三,友元函数(只有在声明中的原型中使用)
1,定义:友元函数是指某些虽然不是类成员却能够访问类的所有成员的函数。类授予它的友元特别访问权。通常同一个开发者会出于技术和非技术的原因,控制类的友元和成员函数(否则当你想更新你的类时,还要征得其它部分的拥有者的同意)
2,例子说明:Time重载操作符* A=B*1.5;对应调用步骤B.operator*(1.5);
操作符左边对应对象,为成员函数调用法则
如果A=1.5*B;不适用于 操作符重载函数(成员函数)
则须定义Time operator* (double m,const Time &t);非成员函数
但是非成员函数不能直接使用私有成员
所以使用友元函数friend Time operator* (double m,const Time &t)
3,友元函数:1>在类中声明,但它不是成员函数。不能使用成员操作符“.”(B.operator*)来调用
2>但有与成员函数访问权限相同
3>不要使用Time::限定符
4>调用时候:A=operator(1.5,B)
4,定义如下
Time operator *(double m,const &t)
{
Time result;
long totalminutes = hours*mult*60+minutes*mult;
result.hours=totalminutes/60;
result.minutes=totalminutes%60;
return result;
}
如果写成如下形式可以不用友元函数(不用访问私有成员)
Time operator* (double m,const &t)
{
return t*m;
}
5,常用的友元:重载<<操作符
1>"<<" 重载之输出对象
void operator<< (ostream &os,Time &t)
{
cout<<t.hours<<" hours "<<t.minutes<<" minutes ";
}
使用:cout<<B;
不能这样使用:cout<<"the time is:"<<B<<"ok";
如果想这样使用
void &operator<< (ostream &os,Time &t)
{
cout<<t.hours<<" hours "<<t.minutes<<" minutes ";
return os;
}
四,类的自动转换和强制类型转换
1,例子:long count = 8; 将整型自动转化为long 型
int *p=10; //非法的
int *p=(int *)10;//将指针设置为地址10
2,接受一个参数的构造函数 可以作为转换函数
explicit 关键字用来关闭自动转换特性
int 强制转换 将待转换的值 四舍五入为最接近的值
五,复习
1)成员函数和友元函数区别
成员函数:类的组成部分,可以直接访问对象的成员而不用使用成员操作符
友元函数:友元函数不是类组成部分,不能隐式访问类成员
2)非成员函数访问类成员,必须是友元么?
要访问私有成员,必须是友元。而访问共有成员可以不是友元
3)重载操作符= () [ ] ->必须使用成员函数来定义