C++PrimerPlus第十一章学习笔记——使用类

前言

此文为本人学习所做一些记录，仅做个人学习之用，加入了我的理解，如发现错误欢迎指正，邮箱：lujialun99 A T gmail.com。

运算符重载

运算符重载是C++的一种多态，C++允许将运算符重载拓展到用户定义的类型，如：将两个数组相加。数组相加通常需要for循环实现，但是在C++中可以定义一个表示数组的类，并重载运算符+。

//a,b,c均为数组
a = b + c;

这种简单的加法表示隐藏了内部机理，并强调了实质，这是OOP的另一个目标。

重载运算符需要使用被称为运算符函数的特殊函数形式。

\\重载运算符op，op必须是有效的C++运算符
operatorop(arg-list)

下面是将时间相加的例子：

Time Time::operator+(const Time & t) const
{
Time sum;
sum.minutes = minutes + t.minutes;
sum.hours = hours + t.hours + sum.minutes / 60;
sum.minutes %= 60;
return sum;
}

operator+()也是由Timer对象调用的，它将第二个Time对象作为参数，并返回一个Time对象，因此可以这样调用：

total=coding.operator+(fixing);
//or
total=coding + fixing

运算符左侧是调用对象，运算符右侧是作为参数被传递的对象。

重载限制

重载后的运算符必须至少有一个操作数是用户定义的类型，这将防止用户为标准类型重载运算符

使用运算符时不能违反原来的语句规则和修改运算符优先级

不能创建新运算符

不能重载下面的运算符



可重载的运算符见书p387

= () [] ->只能通过成员函数进行重载

友元

友元是访问类对象私有部分的另一种形式，友元有三种：

友元函数

友元类

友元成员函数

请看下面这个问题：

A=B+2.75;

将被转换为下面的成员函数调用：

A=B.operator+(2.75);

但是下面的语句又该怎么办：

A=2.75+B;

左侧操作数应该是调用对象，但2.75不是对象，因此我们可以考虑用非成员函数来实现。非成员函数不是由对象调用的，它使用的所有值（包括对象）都是显式参数。

如：

A=operator+(2.75,B);

他的函数原型为：

//运算符左边操作数对应于函数的第一个参数，运算符右边对应于第二个
Time operator*(double m,const Time & t);

常规非成员函数不能直接访问类的私有数据，必须使用友元函数。

创建友元

//首先将此原型放在类声明中
friend Time operator*(double m,const Time & t);

注意：

1. 虽然该函数在类中声明但它不是成员函数，因此不能用成员运算符来调用

2. 虽然该函数不是成员函数但是与成员函数访问权限相同

//然后定义，不要加friend，不要Time::
friend Time operator*(double m,const Time & t)
{
···
}

有了上述定义以后，下面的语句才能实现：

A=2.75+B;

重载<<运算符

<<运算符在C++中已经被重载过很多次，本书的重载主要是作为输出工具重载。cout是一个ostream对象，它可以识别C++所有基本类型的原因是因为ostream类声明中包含了相应的重载的operator<<()定义，如果我们要让它能够识别自己定义的类型，就需要对<<进行重载，千万不要修改iostream文件。

第一种版本

以Time类为例，我们如果用Time类的成员函数来重载那么第一个操作数会是Time类的对象，为了避免这种情况我们是用友元函数来重载。

void operator<<(ostream & os,const Time & t)  //引用效率更高
{
os<<t.hours<<" hours, "<<t.minutes << " minutes";
}

于是可以这样用：

cout << trip;

注意该函数并不是ostream的友元函数，因为它并未访问ostream的私有部分。并且注意到该函数第一个参数为ostream对象，因此除了cout以外，一些经过适当初始化的ostream对象都可以使用该函数，如输出到文件（ofstream）。

第二种版本

第一种版本无法这样使用：

cout << trip << "Tuesday\n";

如果可以使用的话正确的调用顺序应该是这样：

(cout << trip) << "Tuesday\n";

我们知道<<运算符的左侧应该是一个ostream对象，如cout，而cout <

ostream & operator<<(std::ostream & os, const Time & t)
{
os << t.hours << " hours, " << t.minutes << " minutes";
return os;
}

一个矢量类

11章后面的内容主要围绕一个矢量类展开，包括矢量的直角坐标表示、极坐标表示以及矢量运算等内容，可以好好读读代码，这是对前面内容的一次综合运用。

值得注意的内容

C++内置数学函数在使用角度时以弧度为单位，所以度与弧度需转换。

如果方法通过计算得到一个新的类对象，则应考虑是否可以使用类构造函数来完成这种工作。这样可以确保新的对象是按正确的方式创建的。（参考p407）

-运算符有两个，一个是减号，有两个操作数；另一个是负号，一个操作数。

类的自动转换和强制类型转换

以下面这个磅和英石相互转换的类为例，该类的对象表示一个重量：

// stonewt.h -- 源文件cpp见书412
#ifndef STONEWT_H_
#define STONEWT_H_
class Stonewt
{
private:
enum {Lbs_per_stn = 14};      // pounds per stone
int stone;                    // whole stones
double pds_left;              // fractional pounds
double pounds;                // entire weight in pounds
public:
Stonewt(double lbs);          // 一个参数double
Stonewt(int stn, double lbs); //两个参数int double
Stonewt();                    // 默认
~Stonewt();
void show_lbs() const;        // show weight in pounds format
void show_stn() const;        // show weight in stone format
};
#endif

这个类有三个构造函数，分别含有0,1,2个参数。在C++中含有一个参数的构造函数可以将与该参数类型相同的值转换为类对象（这句话有点绕）。

Stonewt myCat;
myCat=19.6;

上面这段代码会使用构造函数来创建一个临时的Stonewt对象，并将19.6作为初始化值。随后采用逐成员赋值方式将该临时对象的内容复制到myCat，这一过程称为隐式转换，该过程是自动进行的。

只有接受一个参数的构造函数才能作为转换函数，但是如果一个构造函数含有两个参数，并且第二个参数提供了默认值，就可以进行自动转换。

Stonewt(int stn, double lbs = 0);

这种自动转换的特性有时候会导致意外的类型转换，为了避免这种情况，C++提供关键字explicit来关闭这种特性。

explicit Stonewt(double lbs);

关闭这种特性后仍可以使用强制转换

Stonewt myCat;
myCat=(Stonewt)19.6;//方式1
myCat=Stonewt(19.6);//方式2

转换函数

构造函数只用于从某种类型到类类型的转换。想要进行相反的转换，必须使用C++运算符函数——转换函数。

//typeName为要转换成的类型
operator typeName();

转换函数时用户定义的强制类型转换，如果定义了从Stonewt到double的转换函数：

Stonewt myCat（19.6）;
/*显式*/
double w=double(myCat);//方式1
double w=(double)myCat;   //方式2
/*隐式*/
double w=myCat；

注意以下几点：

1. 转换函数必须是类方法

2. 转换函数不能指定返回类型

3. 转换函数不能有参数

如果定义了两个转换函数，有可能造成二义性，如同时定义了int和double，在使用时不能进行隐式转换，只能进行显式转换。

C++11可以将转换运算符通过关键字explicit声明为显式的。

转换函数和友元函数

（书上此处的描述有些模糊）

要将double与Stonewt相加，有两种选择：

一是将下面的函数定义为友元函数，让构造函数将double类型的参数转换为Stonewt类型的参数：

//double参数传进此函数会转换为Stonewt参数
operator+（const Stonewt &，const Stonewt &）；

二是将加法运算符重载为一个显式使用double类型参数的函数：

Stonewt operator+（double x）；//Stonewt+double
friend Stonewt operator+（double x,Stonewt &s）；//double + Stonewt

第一种方式依赖于隐式转换，程序更简短，但是每次需要转换时都需要调用构造函数，增加了时间和内存开销。适合偶尔使用

第二种方式正好相反，程序更长但是效率更高。适合经常使用。