【C++】学习笔记——类和对象_5

---

二、类和对象

14. 日期类的实现

上一篇我们已经大致将日期类的重要功能都给实现了，这节将会对日期类进行完善，使其更加便捷好用。
在C++中，内置类型是可以使用流插入（ << ）和流提取（ >> ），我们能不能将流插入和流提取也给重载了呢？使我们的日期类也能使用流插入和流提取？当然可以啦，其实，流插入和流提取是 iostream 库里面的两个函数，类型分别是 ostream 和 istream。

我们可以这样实现：

// 流插入
void operator<<(ostream& out)
{
	out << _year << "年" << _month << "月" << _day << "日" << endl;
}

嗯，看起来没有问题，跑一下试试。

cout << d1;

欸？怎么报错了？一看报错原因，哦，原来运算符重载原本是这样的 d1.operator<<(cout) 。其中，对象实际上是左操作数，cout才是右操作数，所以要这样用才可以：

d1 << cout;

跑一下试试。

哦哦哦，成功了。但是，怎么看起来怪怪的哈哈哈，控制台流入对象？为什么会出现上面的问题呢，因为作为成员函数重载，this指针是一定占据第一个参数的，所以对象必须是左操作数。那怎么办？只能这样用吗，其实也还是有办法的，在类内部的函数才有this指针，全局函数就没有了，所以将上面的函数定义成全局函数就行了。

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

那么问题又来了流插入和流提取的重载函数是要用到对象的成员变量的，但是一般情况下成员变量都是私有的，难道要为了这样的一个流插入和流提取函数，因小失大吗？这里有两种解决方法，首先就是在类内部增设几个 Get 函数，用来获取成员变量的值，另一种方法就是 友元声明 。

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

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

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

在普通函数的声明前面加上 friend ，普通函数就可以自由访问成员变量了。就像朋友一样，一些不对别人公开的东西可以给你公开 。
到这里，我们已经完美解决了流插入运算符的重载了吗？nonono，真正的流插入运算符是支持这样的：

cout << a << b << c << d << endl;

可以连续插入，我们写的流插入重载好像不能连续插入，还等再完善一下。我们解读一下这个 cout ，它是先 cout << a 然后再 cout << b 等等，每次运算后好像 cout 要保留下来，嗯这好解决，我们将我们的函数返回值改成 cout 不就行了。

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

我们来试试：

int main()
{
	Date d1(2222, 2, 2);
	Date d2(3333, 3, 3);
	cout << d1 << d2;
	return 0; 
}

舒服了~（其实好像可以把那个 endl 给去掉），ok，再把流提取光速实现一下。

#include<iostream>
using namespace std;

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

	// 友元声明
	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)
{
	in >> d._year >> d._month >> d._day;
	return in;
}

int main()
{
	Date d1(2222, 2, 2);
	Date d2(3333, 3, 3);
	cin >> d2;
	cout << d1 << d2;
	return 0; 
}

跑跑看：

这下更爽了。

15. const成员

我们来看看下面一段程序：

#include<iostream>
using namespace std;

class Date
{
public:
	Date(int year, int month, int day)
	{
		_year = year;
		_month = month;
		_day = day;
	}
	
	void Print()
	{
		cout << _year << '/' << _month << '/' << _day;
	}

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

int main()
{
	// 在对象前面加上 const
	const Date d1(1111, 1, 1);
	d1.Print();
	return 0;
}

这段程序有问题吗？有。为什么有问题？来看看报错：

没错，这明显就是权限放大的问题。对象在实例化的时候被加上了 const 属性，但是在 Print() 函数中的 this指针 却没有 const 属性，权限放大了，所以报错了。我们如何才能给 this指针 加上 const 属性呢？语法是这样的：

void Print() const
{
	cout << _year << '/' << _month << '/' << _day;
}

对，在函数后面加上 const 即可，不要问为什么，语法就是这样😂。

权限的放大会报错，权限的缩小和平移都不会报错。所以非 const 成员也能调用 const成员函数 。所以要不要给所有的函数都让他变成 const成员函数 呢？当然不行！有的函数就是需要修改成员变量的，不能加 const 。所以，当有个函数，应该只具有 只读 功能时，建议加上 const ，可读可写 的函数就不要加上 const 了。
哦对了，还有一个点，const 修饰的是this指针 ，流插入和流提取函数里的参数都没有 this指针 所以这俩函数不能加哦。

16. 取地址重载

类的六个默认成员函数我们已经介绍了4个了，还有两个没有介绍，剩下俩就是 非const成员的取地址重载 和 const成员的取地址重载。

#include<iostream>
using namespace std;

class A
{
public:
	A* operator&()
	{
		return this;
	}

	const A* operator&() const
	{
		return this;
	}
};

int main()
{
	A a1;
	const A a2;
	cout << &a1 << endl << &a2 << endl;
	return 0;
}

取地址重载函数是默认成员函数，自己不写编译器会自动生成。但是这个函数非常非常的朴实无华，就是单纯的返回 this指针 的地址 。一般没有什么花哨的玩法，但是若是没错都要自己写的话又很麻烦，于是C++将其设置成了默认成员函数，编译器生成就是。
但是有特殊情况需要我们手动实现这个取地址重载函数，比如说：非 const 成员我返回空地址，或者说 const 成员我返回假地址。（真是非常特殊的情况啊）

17. 再谈构造函数

初始化列表

我们之前讲的构造函数是这样的：

#include<iostream>
using namespace std;

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

int main()
{
	Date d1(1234, 5, 6);
	return 0;
}

没问题，但是，我要是加上一个 const成员变量 呢？带有const属性的变量只能在初始化的地方赋初始值，我们应该在构造函数内部赋初始值吗？

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

	const int _n;
};

报错了，为啥？构造函数内不是定义吗，还真不是，构造函数内部是赋值。那定义在哪？定义其实是在一个很奇怪的地方：

#include<iostream>
using namespace std;

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

	const int _n;
};

int main()
{
	Date d1(1234, 5, 6);
	return 0;
}

在构造函数的 =={}==上面，那里才是初始化，那里就是 初始化列表 。在类的 private 域中，成员变量的声明带有的缺省值就是在这里作用的，初始化时有赋初始值就是初始值，没有赋初始值就看声明处的缺省值，没有缺省值就赋随机值，然后再到函数内部进行赋值修改。
因此我们终于了解到了为啥 const成员变量 为啥在构造函数内部会报错了，因为那个时候 const成员变量 已经在初始化时赋过随机值了，在函数内部出现就会出现问题。

1. 每个成员变量在初始化列表中只能出现一次(初始化只能初始化一次)
2. 类中包含以下成员，必须放在初始化列表位置进行初始化：
   引用成员变量
   const成员变量
   没有默认构造函数的自定义成员

当初始化列表没有显示初始化自定义成员的时候，自定义成员的初始化会调用它的默认构造函数，当自定义成员没有默认构造函数时，就会报错，因此 当自定义成员没有默认构造函数时，必须在初始化列表显示定义。
成员变量在类中声明次序就是其在初始化列表中的初始化顺序，与其在初始化列表中的先后次序 。下面放出一个经典例题：

class A
{
public:
    A(int a)
       :_a1(a)
       ,_a2(_a1)
   {}
    
    void Print() {
        cout<<_a1<<" "<<_a2<<endl;
   }
private:
    int _a2;
    int _a1;
};
int main() {
    A aa(1);
    aa.Print();
}
//A. 输出1  1
//B.程序崩溃
//C.编译不通过
//D.输出1  随机值

因为声明的顺序才是初始化列表中的初始化顺序，而 a2 先声明，所以 a2 先定义，a2 定义的时候赋的值是 a1 ，此时 a1 还没有定义，所以是随机值，因此本题选D。

18. explicit关键字

构造函数不仅可以构造与初始化对象，对于单个参数或者除第一个参数无默认值其余均有默认值的构造函数，还具有类型转换的作用。比如说：

int main()
{
	// 这两种都是构造
	A a1(123);
	A a2 = 666;
	return 0;
}

第二种为啥可以呢，因为 666 其实是会被隐式类型转换成自定义类型，然后再拷贝构造给 a2 。当我们不想这种情况出现时，就可以在构造函数前加上 explicit 关键字。

explicit A(int a)
{
	//
}

此时那句 A a2 = 666 就不能够编译成功了。

19. static成员

如果有一个类 A，我们怎么才能知道它构造了多少个对象呢？有个很简单的办法，就是搞一个全局变量，然后每个构造函数都让这个变量 +1 ，这个办法确实可以，但是不够安全，万一有个谁谁谁手动修改这个全局变量就出问题了。
C++讲究封装，我们其实可以将这个变量搞成类的成员变量，但是每次构造函数令这个变量 +1 ，加的是哪个对象的变量？每个对象都包含这个成员变量，无法统计。我们可以将其设置成静态变量，这下它的生命周期变成全局了，就可以了。
注意：类里面的静态变量声明处不能给缺省值，静态成员变量一定要在类外进行初始化。
静态成员函数没有this指针。

特性

1. 静态成员为所有类对象所共享，不属于某个具体的对象，存放在静态区
2. 静态成员变量必须在类外定义，定义时不添加static关键字，类中只是声明
3. 类静态成员即可用 类名::静态成员 或者 对象.静态成员 来访问
4. 静态成员函数没有隐藏的this指针，不能访问任何非静态成员
5. 静态成员也是类的成员，受public、protected、private 访问限定符的限制

---

未完待续