一、构造函数的初始化列表

构造函数赋值

对于构造函数来说，函数体中的语句只能将其称作为赋初值，而不能称作初始化。因为初始化只能初始化一次，而构造函数体内可以多次赋值。

class Date
{
public:
	Date(int year, int month, int day)
	{
		_year = year;
		_month = month;
		_day = day;
	}
private:
	int _year;
	int _month;
	int _day;
};
1
2
3
4
5
6
7
8
9
10
11
12
13
14

初始化列表

初始化列表以冒号开始，用逗号分割数据成员，每个成员变量后跟一个放在括号中的初始值或者表达式，只有构造函数和拷贝构造函数中存在初始化列表。如图：

对于所有的内置类型，如果没有显示写出初始化列表，编译器会自动生成，初始值为随机值。

初始化列表的特征

只能初始化一次

每个成员变量只能在初始化列表中出现一次，因为变量只能初始化一次

三种变量

类中有以下成员，只能在初始化列表初始化：

• 引用成员变量，因为定义引用成员变量时必须进行初始化，而类中的成员变量只能在初始化列表处初始化
• const成员变量，C++种const修饰的是常量，必须在定义时初始化
• 自定义类型成员变量（该类没有默认的构造函数），这是因为如果没有在初始化列表进行初始化，编译器会默认生成初始化列表，调用该类默认的构造函数，而如果该类没有默认的构造函数就会报错。如图：
  

声明次序

成员变量在类中声明次序就是其在初始化列表中的初始化顺序，与其在初始化列表中的先后次序无关

explicit

单参构造函数具有类型转换的作用：

这里将2022赋值给Date类型的对象发生了隐式类型转换，看起来像是直接用2022给Date类对象的，降低了代码可读性，所以引入了explicit关键字（中文：清晰的，明确的），禁止单参构造函数的隐式转换，提升代码的可读性。如图：

explicit修饰构造函数后，程序编译过程中报错。

二、 static

概念及简单应用

static修饰的成员变量称为静态类成员；satatic修饰的成员函数称为静态成员函数。静态的成员变量一定要在类外进行初始化。即类中声明，类外定义。

实现一个类，统计程序中创建了多少个对象

class A
{
public:
	A()
	{
		//调用构造函数时计数器自增
		++_count;
	}
	A(const A& a)
	{
		//调用拷贝构造函数时计数器自增
		++_count;
	}
	static int GetCount()
	{
		return _count;
	}
	

private:
	//声明静态成员变量
	static int _count;
};

//静态成员变量，类外定义并初始化
int A::_count = 0;

int main()
{
	A a1;
	A a2;
	A a3(a2);
	cout << A::GetCount() << endl;
	system("pause");
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36

特征

静态成员变量：

• 静态成员为所有类对象共享，不属于某个具体的对象，也不影响sizeof大小
• 类外定义并初始化，类中声明，声明时加static关键字，定义不加，不能在初始化列表初始化
• 两种访问方式，类名::静态成员变量名，或者对象.静态成员变量名（任何一个对象名都可以）

静态成员函数：

• 静态成员函数没有隐藏的this指针，不能访问非静态成员变量
• 静态成员函数不能被const修饰，因为const实质上修饰的就是隐藏的this指针
• 静态成员函数也有public、protected、private3种访问级别，有返回值

关于static的两个问题

1. 静态成员函数可以调用非静态成员函数吗？
   不能，因为静态成员函数没有隐藏的this指针
2. 非静态成员函数可以调用类的静态成员函数吗？
   可以，所有类的成员函数都可以调用静态成员函数

三、友元

友元函数

流插入运算符"<<"的重载

	ostream& operator<<(ostream& _cout)
	{
		_cout << _year << "-" << _month << "-" << _day;
		return _cout;
	}
1
2
3
4
5

注：ostream类是c++标准输出流的一个基类，_cout是ostream类的一个对象。
这里将"<<"重载成成员函数后，cout的输出流对象和隐含的this指针在抢占第一个参数的位置。this指针默认是第一个参数，所以重载以后对象会成为左操作数。但是实际使用中cout需要是第一个形参对象，才能正常使用。所以我们要将operator<<重载成全局函数。但是这样的话，又会导致类外没办法访问成员，那么这里就需要友元来解决。

友元函数的概念

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

流插入运算符"<<"正确的重载方式

类外定义运算符重载函数：

//将类对象放在第二个参数的位置
ostream& operator<<(ostream& _cout, const Date& d)
{
	_cout << d._year << "-" << d._month << "-" << d._day;
	//返回_cout支持连续输出
	return _cout;
}
1
2
3
4
5
6
7

类中声明：

friend ostream& operator<<(ostream& _cout,const Date &d);
1

利用友元函数的特性，在类中声明之后便可以访问成员的私有变量。

流提取运算符">>"重载

类外定义重载函数：

istream& operator>>(istream& _cin,  Date& d)
{
	_cin >> d._year;
	_cin >> d._month;
	_cin >> d._day;
	return _cin;
}
1
2
3
4
5
6
7

类内声明：

friend istream& operator>>(istream& _cin, Date& d);
1

友元函数的特征

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

友元类

在一个类中声明另一个类为友元类，如在Time类中声明Date类为友元类：

friend class Date;
1

特征

• 友元类是单向的，如上面Date类是Time类的友元类，Date类中的成员函数便可以访问Time类的私有成员变量，但是Time类不能访问Date类的私有成员变量
• 友元类不能传递，B是A的友元，C是B的友元，则不能说明C时A的友元

内部类

概念

个类定义在另一个类的内部，这个内部类就叫做内部类。注此时这个内部类是一个独立的类，它不属于外部类，更不能通过外部类的对象去调用内部类。内部类就是外部类的友元类，但是外部类不是内部类的友元。

特征

• 内部类可以直接访问外部类中的static、枚举成员，不需要外部类的对象类名。
• sizeof(外部类)=外部类，和内部类没有任何关系