类和对象(三)

默认成员函数

接下来继续看剩下的两个默认成员函数。

const成员函数

将const修饰的成员函数称之为const成员函数，const修饰成员函数放到成员函数参数列表的后 ⾯。const实际修饰该成员函数隐含的this指针，表明在该成员函数中不能对类的任何成员进⾏修改。

先来看例子：

所以C++设计了使用 const 修饰成员函数来达到目的。

所以，只需在成员函数参数列表后添加 const ，就能解决问题。

所以，对于一个类，如果我们希望所有的成员函数都默认为const，即不修改对象状态，我们可以使用const关键字来修饰成员函数。

---

取地址运算符重载

取地址运算符重载分为普通取地址运算符重载和 const 取地址运算符重载，⼀般这两个函数编译器⾃动 ⽣成的就可以够我们⽤了，不需要去显⽰实现。取地址的意思就是返回当前对象的地址，对于成员函数来讲，this指针就是它的地址。

class Date
{
public:
	//普通取地址运算符重载
	Date* operator&()
	{
		return this;
	}

	//const取地址运算符重载，返回一个const Date* 的指针。
	const Date* operator&() const
	{
		return this;
	}

private:
	int _year;
	int _month;
	int _day;
};

---

友元

友元就是提供了⼀种突破类访问限定符封装的⽅式，友元分为：友元函数和友元类，在函数声明或者类 声明的前⾯加 friend，并且把友元声明放到⼀个类的⾥⾯。外部友元函数可访问类的私有和保护成员，友元函数仅仅是⼀种声明，他不是类的成员函数。友元函数可以在类定义的任何地⽅声明，不受类访问限定符限制。

#include<iostream>

class Date
{
public:
	Date(int year = 1, int month = 1, int day = 1)
	{
		_year = year;
		_month = month;
		_day = day;
	}

	//友元函数声明
	friend void func(const Date& d);

private:
	int _year;
	int _month;
	int _day;
};

void func(const Date& d)
{
	std::cout << d._year << "年" << d._month << "月" << d._day << "日" << std::endl;
}

int main()
{
	Date d1;
	func(d1);
	return 0;
}

并且⼀个函数可以是多个类的友元函数。

#include<iostream>

//前置声明，否则Date类中的友元函数不认识A类
class A;

class Date
{
public:
	Date(int year = 1, int month = 1, int day = 1)
	{
		_year = year;
		_month = month;
		_day = day;
	}

	//友元函数声明
	friend void func(const Date& d, const A& a);

private:
	int _year;
	int _month;
	int _day;
};

class A
{
	friend void func(const Date& d, const A& a);

private:
	int _a1 = 1;
	int _a2 = 2;
};


void func(const Date& d, const A& a)
{
	std::cout << d._year << "年" << d._month << "月" << d._day << "日" << std::endl;
	std::cout << a._a1 << std::endl;
}

int main()
{
	Date d1;
	A a;
	func(d1, a);
	return 0;
}

友元类中的成员函数都可以是另⼀个类的友元函数，都可以访问另⼀个类中的私有和保护成员。

#include<iostream>

class Date
{
public:
	Date(int year = 1, int month = 1, int day = 1)
	{
		_year = year;
		_month = month;
		_day = day;
	}
	friend class A;

private:
	int _year;
	int _month;
	int _day;
};

class A
{
public:
	void func(const Date& d)
	{
		std::cout << d._year << "-" << d._month << "-" << d._day << std::endl;
		std::cout << _a1 << ' ' << _a2 << std::endl;
	}
private:
	int _a1 = 1;
	int _a2 = 2;
};

int main()
{
	Date d;
	A a;
	a.func(d);
	return 0;
}

友元类的关系是单向的，不具有交换性。比如A类是B类的友元，但是B类不是A类的友元。而且友元类关系是不能传递，如果A是B的友元，B是C的友元，但是A不是C的友元。

---

赋值重载流插入和流提取

上一篇的利用运算符重载在类中实现了各种操作(详见：点这里)，接下来就在类内实现流插入和流提取的重载(也就是在类内实现自定义类型的输入输出)。

流插入

通过查阅资料可以看到，cin 是 istream 类型的对象，cout 是 ostream 类型的对象，如果要重载，则类型简单可以写为：

但这样写是有问题的，是不对的。

其报错信息显示出，出现这样的错误本质上是因为参数不匹配造成的。

如果改为这样，就不会报错，也能正常运行。

所以，重载 >> 和 << 时，需要重载为全局函数，因为重载为成员函数，this指针默认抢占了第⼀个形参位置，第⼀个形参位置是左侧运算对象，调⽤时就变成了 << cout 对象，不符合使⽤习惯和可读性。重载为全局函数把 ostream/istream 放到第⼀个形参位置就可以了，第⼆个形参位置当类类型对象。

但又出现了新的问题，就是无法访问类内的成员变量。所以我们可以使用C++的 友元 来访问类内部的成员变量。

但其还不支持连续赋值，和=等运算符一样，它一定是要支持连续赋值的，所以还要进行改造。

但与=运算符不同，流插入流提取运算符是从左到右赋值的。所以得：

#include<iostream>
using namespace std;

class Date
{
public:
	// 全缺省的构造函数
	Date(int year = 1900, int month = 1, int day = 1)
	{
		_year = year;
		_month = month;
		_day = day;
	}

	// 拷贝构造函数
	Date(const Date& d)
	{
		_year = d._year;
		_month = d._month;
		_day = d._day;
	}

	// 赋值运算符重载
	Date& operator=(const Date& d)
	{
		_year = d._year;
		_month = d._month;
		_day = d._day;
		return *this;
	}

	// 析构函数
	//日期类无要释放的资源，编译器自动生成的析构即可满足要求。

	void Print()
	{
		std::cout << _year << "-" << _month << "-" << _day << std::endl;
	}

    //友元函数声明
	friend ostream& operator<<(ostream& out, const Date& d);

private:
	int _year;
	int _month;
	int _day;
};

ostream& operator<<(ostream& out, const Date& d)
{
	out << d._year << "年" << d._month << "月" << d._day << "日" << endl;
	return out;
}

void test()
{
	Date d1(2024, 6, 6);
	Date d2(2006, 1, 2);
	cout << d1 << d2;
}

int main()
{
	test();
	return 0;
}

接下来就是流提取得重载函数。

流提取

流提取是 istream 类型的对象，所以：

#include<iostream>
using namespace std;

class Date
{
public:
	// 全缺省的构造函数
	Date(int year = 1900, int month = 1, int day = 1)
	{
		_year = year;
		_month = month;
		_day = day;
	}

	// 拷贝构造函数
	Date(const Date& d)
	{
		_year = d._year;
		_month = d._month;
		_day = d._day;
	}

	// 赋值运算符重载
	Date& operator=(const Date& d)
	{
		_year = d._year;
		_month = d._month;
		_day = d._day;
		return *this;
	}

	// 析构函数
	//日期类无要释放的资源，编译器自动生成的析构即可满足要求。

	void Print()
	{
		std::cout << _year << "-" << _month << "-" << _day << std::endl;
	}

	friend ostream& operator<<(ostream& out, const Date& d);
	friend istream& operator>>(istream& in, Date& d);

private:
	int _year;
	int _month;
	int _day;
};

ostream& operator<<(ostream& out, const Date& d)
{
	out << d._year << "年" << d._month << "月" << d._day << "日" << endl;
	return out;
}

istream& operator>>(istream& in, Date& d)
{
	cout << "请输入年月日：";
	in >> d._year >> d._month >> d._day;
	return in;
}

void test()
{
	Date d1(2024, 6, 6);
	Date d2(2006, 1, 2);
	cin >> d1 >> d2;
	cout << d1 << d2;
}

int main()
{
	test();
	return 0;
}

---

内部类

如果⼀个类定义在另⼀个类的内部，这个内部类就叫做内部类。内部类是⼀个独立的类，跟定义在 全局相比，他只是受外部类类域限制和访问限定符限制，所以外部类定义的对象中不包含内部类。并且内部类默认是外部类的友元类。

简单来说就是，内部类可以访问到外部类成员，但外部类不能访问到内部类得成员。

#include<iostream>

class Date
{
public:
	Date(int year = 1, int month = 1, int day = 1)
	{
		_year = year;
		_month = month;
		_day = day;
	}
	class A
	{
	public:
		void func(const Date& d)
		{
			std::cout << d._year << "-" << d._month << "-" << d._day << std::endl;
			std::cout << _a1 << ' ' << _a2 << std::endl;
		}
	private:
		int _a1 = 1;
		int _a2 = 2;
	};
	
private:
	int _year;
	int _month;
	int _day;
};

int main()
{
	Date d1;

	Date::A a;

	a.func(d1);

	return 0;
}

---

匿名函数

直接⽤ 类型 (实参) 定义出来的对象叫做匿名对象，相⽐之前我们定义的 类型 对象名(实参) 定义出来的叫有名对象。匿名对象⽣命周期只在当前⼀⾏，⼀般用于临时定义⼀个对象。

#include<iostream>

class Date
{
public:
	Date(int year = 1, int month = 1, int day = 1)
	{
		_year = year;
		_month = month;
		_day = day;
	}

	void Print()
	{
		std::cout << _year << "-" << _month << "-" << _day << std::endl;
	}

private:
	int _year;
	int _month;
	int _day;
};

int main()
{
	//有名函数
	Date d1;
	d1.Print();

	//匿名函数
	Date().Print();

	return 0;
}