【c++ primer】第十一章 使用类

一，操作符重载

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 Timeoperator* (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）重载操作符= （） [ ] ->必须使用成员函数来定义