C++ —— 类和对象（三）

友元

友元分为：友元函数和友元类

友元提供了一种突破封装的方式，有时提供了便利。但是友元会增加耦合度，破坏了封装，所以友元不宜多用。

友元函数

问题：现在我们尝试去重载operator<<，然后发现我们没办法将operator<<重载成成员函数。因为cout的输出流对象和隐含的this指针在抢占第一个参数的位置。this指针默认是第一个参数也就是左操作数了。但是实际使用中cout需要是第一个形参对象，才能正常使用。所以我们要将operator<<重载成全局函数。但是这样的话，又会导致类外没办法访问成员，那么这里就需要友元来解决。operator>>同理。

友元函数可以直接访问类的私有成员，它是定义在类外部的普通函数，不属于任何类，但需要在类的内部声明，声明时需要加friend关键字。

说明:

• 友元函数可访问类的私有和保护成员，但不是类的成员函数。
• 友元函数不能用const修饰。
• 友元函数可以在类定义的任何地方声明，不受类访问限定符限制。
• 一个函数可以是多个类的友元函数。
• 友元函数的调用与普通函数的调用和原理相同。

友元类

格式：在友元类里加上 friend class [友元类名] 声明;

友元类的所有成员函数都可以是另一个类的友元函数，都可以访问另一个类中的非公有成员。

友元关系是单向的，不具有交换性。
类的私有成员变量，但想在Time类中访问Date类中私有的成员变量则不行。

友元关系不能传递
如果B是A的友元，C是B的友元，则不能说明C时A的友元

内部类

如果一个类定义在另一个类的内部，这个内部类就叫做内部类。注意此时这个内部类是一个独立的类，它不属于外部类，更不能通过外部类的对象去调用内部类。外部类对内部类没有任何优越的访问权限。

注意：
内部类就是外部类的友元类。
注意友元类的定义，内部类可以通过外部类的对象参数来访问外部类中的所有成员。但是外部类不是内部类的友元。

特性：

1. 内部类可以定义在外部类的public、protected、private都是可以的。
2. 注意内部类可以直接访问外部类中的static、枚举成员，不需要外部类的对象/类名。
3. sizeof(外部类)=外部类，和内部类没有任何关系。

运算符重载

C++为了增强代码的可读性引入了运算符重载。

运算符重载，就是对已有的运算符重新进行定义，赋予其另一种功能，以适应不同的数据类型。

运算符重载是具有特殊函数名的函数，也具有其返回值类型，函数名字以及参数列表，其返回值类型与参数列表与普通的函数类似。

**函数名字为：**关键字operator后面接需要重载的运算符符号。
**函数原型：**返回值类型 operator操作符(参数列表…){};

公认的四个特点

1. 在已有的运算符范围内重载，不能通过连接其他符号来创建新的操作符：比如operator@。
2. 重载之后的运算符不能改变运算符的优先级和结合性，也不能改变运算符操作数的个数及语法结构。
3. 重载操作符必须有一个类类型或者枚举类型的操作数。
4. 保持重载运算符之后运算符本身的自然含义，比如加操作不要重载成减法操作等。

其他注意点：

1. 用于内置类型的操作符，其含义不能改变，例如：内置的整型+，不能改变其含义。
2. 操作符有一个默认的形参this，限定为第一个形参。
3. 它与拷贝构造函数与析构函数一样，要注意深拷贝浅拷贝的问题。
4. 重载方法：类成员函数、友元函数。

类属关系运算符 “.” 、成员指针运算符 “.*” 、作用域运算符 “::” 、sizeof运算符和三目运算符 “?:” 以上5个运算符不能重载。

运算符类型	运算符
双目算术运算符	+ (加)，-(减)，*(乘)，/(除)，% (取模)
关系运算符	==(等于)，!= (不等于)，< (小于)，> (大于>，<=(小于等于)，>=(大于等于)
逻辑运算符	||(逻辑或)，&&(逻辑与)，!(逻辑非)
单目运算符	+ (正)，-(负)，*(指针)，&(取地址)
自增自减运算符	++(自增)，–(自减)
位运算符	(按位或)，& (按位与)，~(按位取反)，^(按位异或),，<< (左移)，>>(右移)
赋值运算符	=, +=, -=, *=, /= , % = , &=, |=, ^=, <<=, >>=
空间申请与释放	new, delete, new[ ] , delete[]
其他运算符	()(函数调用)，->(成员访问)，,(逗号)，[](下标)

-	-
不可重载	类属关系运算符 “.” 、成员指针运算符 “.*” 、作用域运算符 “::” 、sizeof运算符和三目运算符 “?:”

重载代码示例

常用的重载

#include <iostream>
using namespace std;


class myPoint
{
public:
	//默认构造
	myPoint(int ,int );
	//拷贝构造
	myPoint(const myPoint&);
	//前置++
	myPoint& operator++();
	//后置++
	myPoint operator++(int);
	//+
	myPoint operator+(const myPoint&);
	//=
	myPoint operator=(const myPoint&);
	//==
	bool operator==(const myPoint&);
	// <<
	friend ostream& operator<<(ostream& , const myPoint& );
	~myPoint();

private:
	int _x;
	int _y;
};

myPoint::myPoint(int x = 0,int y = 0)
	:_x(x), _y(y)
{
}

myPoint::myPoint(const myPoint& p)
{
	_x = p._x;
	_y = p._y;
}

myPoint& myPoint::operator++()
{
	_x++, _y++;
	return *this;
}

myPoint myPoint::operator++(int)
{
	myPoint p = *this;
	_x++, _y++;
	return *this;
}

myPoint myPoint::operator+(const myPoint& p1)
{
	myPoint p;
	p._x = _x + p1._x;
	p._y = _y + p1._y;
	return p;
}

myPoint myPoint::operator=(const myPoint& p1)
{
	_x = p1._x;
	_y = p1._y;
	return *this;
}

bool myPoint::operator==(const myPoint& p)
{
	if (_x == p._x && _y == p._y)
		return true;
	else
		return false;
}

myPoint::~myPoint()
{
}


ostream& operator<<(ostream& out, const myPoint& p)
{
	out << "x的值是：" << p._x << "  y的值是：" << p._y << endl;
	return out;
}
int main()
{
	myPoint p;
	myPoint p1 = p;//拷贝
	p++;
	++p;
	p = p + p1;//赋值
	cout << p;
	return 0;
}