C++使用类

运算符重载

C++允许将运算符重载扩展到用户定义的类型，C++将会根据操作数的数目和类型来决定使用哪种操作，运算符重载的格式如下:

operatorop(argumet-list)

即由关键字operator，运算符op，()里的参数列表三部分组成，op必须是有效的C++运算符

例如：operator+()，这里代表着要重载+运算符

我们可以通过一个例子来看看运算符重载的便利

我们不使用运算符重载进行两个对象的计算
#include<iostream>using namespace std;class Time
{private:int hours;int minutes;public:Time(){hours = minutes = 0;}Time(int h, int m = 0){hours = h;minutes = m;}Time Sum(const Time &t) const//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;}void show(){cout<<"hours: "<<hours<<"minutes: "<<minutes<<endl;}
};
int main()
{Time a(10,55);Time b(1,20);a.show();b.show();Time c = a.Sum(b);c.show();return 0;
}
这样就只能通过常规的函数方法来进行求和，即必须通过访问成员函数的方式，而我们使用运算符重载时

我们就能够直接使用+运算符进行计算

我们也可以将operate+()当做一个函数来理解

两者的运算结果都是相等的

总之

operator+()函数的名称使得使用函数表示法或者运算符表示法来调用它，编译器会根据操作数的类型来决定如果进行调用

注意：

在上述的代码中，Sum函数的返回值不能是一个引用，因为我们将引用作为参数是为了提高效率，如果按值传递Time对象，两种的功能相同，但是传递引用，速度更快，使用的内存更少，但是返回值却不能是引用，因为函数会创建一个新的对象来表示两个对象的和，返回对象将会创建对象的副本，则函数调用可以使用它，如果传递的是对象的引用，因为我们定义的对象sum是局部变量，这个变量会在函数结束时被删除，因此引用会指向一个不存在的对象

这样的结果是会导致编译器发生警告

运算符重载限制

C++对用户自定义的运算符重载是有着一定的限制

1.重载后的运算符必须至少有一个操作数是用户自定义的类型，这将会防止用户为标准类型重载运算符，例如将减法运算符重载为计算两个整型的和

2.使用运算符不能违反原来的句法规则，例如不能将%运算符重载为只使用一个操作数，也不能修改运算符的优先级，就像我们上面的例子，将+运算符重载为两个类的相加，得到的新运算符与原来的+具有同样的优先级

3.不能创造新的运算符

4.部分的运算符不允许重载（sizeof运算符，.成员运算符，.*成员指针运算符，::作用域解析运算符，?:条件运算符等）

5.大部分的运算符可以通过成员函数或者非成员函数进行重载，例如

注意：

我们使用非成员函数时是访问不到私有的n的，只能将其改为公有的部分或者通过成员函数才能进行访问，这里是将其改为公有部分去访问(这样做非常不好，尽量不要这么去使用)

但是（ =赋值运算符，()函数调用运算符，[]下标运算符，->通过指针访问类成员运算符）只能通过成员函数进行重载

我们来看一串代码，就可以知道为什么=赋值运算符，()函数调用运算符，[]下标运算符，->通过指针访问类成员运算符只能通过成员函数进行重载

这个代码的输出结果为

我们对这个代码进行分析一下：

在main函数中，我们先使用Num创建了一个对象a，此时我们并没有对其进行初始化，因此会调用默认构造函数，进而打印出No，但是，第二条语句a=10好像是把我们赋值运算符的功能进行了重载，否则的话，这条语句就是尝试将一个整型的常量去赋值给一个Num类的对象，这会导致类型不匹配，但是我们编译却没有出错，因此，我们可以得知，当我们的类中没有定义赋值运算符重载的功能时，但是在代码中出现了赋值运算，程序就会调用与赋值运算符右侧值类型匹配的构造函数，因此输出的结果为YES，此时我们可以将a=10就理解为一个a(10)的操作

但是，当我们的类里有运算符重载的操作时，程序就只会去调用我们定义的重载函数

此时我们就编写了一个赋值运算符重载的函数，当出来赋值操作时，编译器就会去调用我们编写的函数，而不是再去调用参数类型匹配的构造函数

注意：

如果我们不在类里面去定义一个赋值运算符重载的函数，而是定义了一个非成员函数的赋值运算符重载的函数，这样会导致编译器报错，因为有构造函数也可以满足我们的赋值操作，编译器不知道要去调用哪一个函数，而加号运算符不会出现这样的操作，因为它们不会去调用构造函数，这就是为什么=赋值运算符，()函数调用运算符，[]下标运算符，->通过指针访问类成员运算符）只能通过成员函数进行重载的原因

友元

友元的介绍

C++控制对于类对象私有部分的访问，通常，公有类方法提供是唯一的访问途径，但是有时候这种限制太过严格，以至不适用于某些编程问题，在这种特定的情况下，C++提供了另外一种形式的访问权限——友元，友元有三种

友元函数

友元类

友元成员函数

通过让函数成为类的友元，可以赋予该函数与类成员函数相同的访问权限，即可以访问到类的私有部分的成员

为什么需要友元

在为类重载二元运算符时，通常需要友元，例如下面这个代码

我们上面进行了+运算符的重载，在这个基础上再加上*运算符的重载

#include<iostream>using namespace std;class Time
{private:int hours;int minutes;public:Time(){hours = minutes = 0;}Time(int h, int m = 0){hours = h;minutes = m;}//Time Sum(const Time &t) constTime  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;}Time operator*(double num){Time result;long total = hours * num *60 + minutes * num;result.minutes = total % 60;result.hours = total / 60;return result;void show(){cout<<"hours: "<<hours<<" minutes: "<<minutes<<endl;}
};int main()
{Time a(1,30);Time b(1,20);Time d;Time c;a.show();b.show();d = a + b;c = b * 2.0;c.show();
}

在这个例子中，加法运算符的重载结合的是两个Time值，而乘法运算符将一个Time类的对象与一个double类型的值进行了结合，这就限制了该运算符的使用方式，左侧的操作数b是调用对象

c = b * 2.0;

将会被转化为

c = b.operator*(2.0);

那么如果出现了 c = 2.0 * b;这条语句会发生什么呢？

从概念上来说，b*2.0与2.0*b应该是相同的，但是第一个表达式的值不对应与成员函数，因此2.0不是Time类的对象，因此，编译器不能使用成员函数调用来替换这个表达式,如果使用这样进行编译时，编译器会进行明确的报错

解决这个问题的方法

1.告知所有人只能按照b*2.0这样的格式编写，但是这样对我们并不友好

2.再编写一个非成员函数，让2.0*b这种类型也能匹配，但是这样又会出现一个问题，即我们非成员函数无法去访问我们的私有成员，例如下图

定义了一个非成员函数，但是在非成员函数里尝试去访问Time类中的私有成员，这样编译器就会发出警告，消除警告可以像我们上面所说的将私有成员该为公有成员(非常不好)

由于定义非成员函数不能直接去访问类里面的私有成员，那么我们应该怎么让非成员函数也能够去访问类的私有成员呢？

使用友元函数，就可以去访问类的私有成员

创建友元

友元函数的创造步骤如下

1.将函数的原型放在类声明中，并在声明前加上关键字friend

2.编写函数定义，因为不是类成员函数，因此不需要加上类和作用域解析运算符，此外，在函数定义中也不需要加上关键字friend

按照我们上述的问题，编写能够匹配2.0*b的非成员函数，定义为友元函数

在类的声明中

非成员函数的定义

常用友元：重载<<运算符

一个很有用的类的特性是，可以对<<运算符进行重载，使之能和cout一起来显示对象的内容，例如我们前面使用过的成员函数show()，假如我们有一个Time类的对象tip，如果我们可以使用下面这种方式来显示会比使用show来显示更好

cout<<trip;

我们可以这样做是因为<<是可以被重载的运算符，最初<<运算符是C和C++的位运算符符，ostream类对这个运算符进行了重载，将其转化为了一个输出工具，而cout是一个ostream类的对象，它是智能的，能够识别所有的C++基本类型，因为对于每种基本类型来说，ostream类声明中都包含了相对应的重载的operator<<()定义，因此，要使cout能够识别Time对象，一种方法就是讲一个新的函数运算符定义添加到ostream类声明中，但是这样非常不好，这样会在标准接口上浪费时间，相反，通过Time类声明来让Time类知道如何使用cout，即在Time类里面进行重载，方法如下所示：

1.<<的第一种重载

在Time类中声明

定义函数

这样就可以使用cout<<trip

2.<<的第二种重载

我们上面所写的第一种重载无法进行连续的输出，例如

这样编译器会发出警告

因为C++从左往右读取输出语句，例如int x = 1, y = 2;

cout<<x<<y;等同于(cout<<x)<<y;在这里(cout<<x)的返回值类型还是cout类型，因此还能继续输出结果，而上面定义的输出的结果是void类型，因此无法满足连续的输出，为了保证我们能够连续的输出，我们就要对第一种重载的返回值进行更改.

声明在Time类中

定义operator<<()

调用函数

在我们定义函数时，我们可以不像之前的代码一样，先定义一个临时的类的对象，对其进行操作之后再返回，而是直接使用构造函数去返回，这样写比较简洁，即如下

这样相当于创建了一个无名的新对象，并返回了该对象的副本，这就确保了新的Vector对象是根据构造函数制定的标准规则创建的

提示：

如果方法通过计算得到一个新的类对象，则应该考虑是否可以使用构造函数来完成这个工作，这样可以避免麻烦，并且确保新的对象是按照正确的方式创建的

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

自动类型转换

我们通过下面这个例子来看看C++类的自动转换

在这个程序中，我们定义了一个Sto类，接下来我们使用这个类来创造一个对象a和b，但是在运用时却出现了b = 136.2,在这条语句中，程序将自动使用Sto(double n2)这个构造函数来创建一个临时的对象，随后采用逐成员赋值的方式将该临时对象的内容复制到b中，这一个过程是隐式进行的，因此不需要进行强制类型转换

C++新增的关键字explicit可以关闭类的自动类型转换

只需要在构造函数前加上explicit关键字，这样关闭隐式的转换之后，再出现这样的赋值语句就会出错

转换函数

我们在类的自动转换中将一个数字赋值给我们类的对象，我们在这里还可以进行相反的操作，即将一个类的对象赋值给我们的变量，这需要使用到转换函数

转换函数是用户自定义的强制类型转换，可以像使用强制类型转换那样去使用它们

转换函数的格式如下：

operator 要转换的类型();

注意：

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

2.转换函数不能指定返回类型，因为要转换的类型指出了我们要将类转换为什么类型，因此不需要指定返回

3.转换函数不能有参数，因为转换函数是类方法，它需要通过类对象来调用，从而告知了函数要转换的值，因此不需要参数

我们按照上面的例子定义转换函数并调用