Lesson 02 类与对象 (终)

C++：渴望力量吗，少年？

---

一、初始化列表

  在构造函数中，以一个冒号开始，接着是一个以逗号分隔的数据成员列表，每个"成员变量"后面跟一个放在括号中的初始值或表达式。
【注意】
（1）每个成员变量在初始化列表中只能出现一次(初始化只能初始化一次)。
（2）类中包含以下成员，必须放在初始化列表位置进行初始化：
    a. 引用成员变量
    b. const成员变量
    c. 没有默认构造函数的自定义类型成员
（3）尽量使用初始化列表初始化，因为不管你是否使用初始化列表，对于自定义类型成员变量， 一定会先使用初始化列表初始化。
（4）成员变量在类中声明次序就是其在初始化列表中的初始化顺序，与其在初始化列表中的先后次序无关。
（下面的代码比较长，是对上述内容的实现）

typedef int DataType;
class Stack
{
public:
	//Stack(size_t capacity)
	//{
	//	cout << "Stack()" << endl;

	//	_array = (DataType*)malloc(sizeof(DataType) * capacity);
	//	if (NULL == _array)
	//	{
	//		perror("malloc申请空间失败!!!");
	//		return;
	//	}

	//	_capacity = capacity;
	//	_size = 0;
	//}

	Stack(size_t capacity)//把上面的代码改成下面这段，这段代码就是初始化列表和函数体的混合使用
		:_array((DataType*)malloc(sizeof(DataType) * capacity))
		,_size(0)
		,_capacity(capacity)
	{
		cout << "Stack()" << endl;
		if (NULL == _array)
		{
			perror("malloc申请空间失败!!!");
			return;
		}

		memset(_array, 0, sizeof(DataType) * _capacity);
	}

	// s1(s)
	Stack(const Stack& s)
	{
		cout << "Stack(Stack& s)" << endl;
		// 深拷贝
		_array = (DataType*)malloc(sizeof(DataType) * s._capacity);
		if (NULL == _array)
		{
			perror("malloc申请空间失败!!!");
			return;
		}

		memcpy(_array, s._array, sizeof(DataType) * s._size);
		_size = s._size;
		_capacity = s._capacity;
	}

	Stack& operator=(const Stack& st)
	{
		if (this != &st)
		{
			// ...
		}
		return *this;
	}

	void Push(DataType data)
	{
		// CheckCapacity();
		_array[_size] = data;
		_size++;
	}

	~Stack()
	{
		cout << "~Stack()" << endl;

		free(_array);
		_array = nullptr;
		_size = _capacity = 0;
	}
private:
	// 内置类型
	DataType* _array;
	int _capacity;
	int _size;
};

class MyQueue
{
public:
	MyQueue(int capacity = 10)
		:_st1(capacity)
		,_st2(capacity)
	{}

private:
	Stack _st1;
	Stack _st2;
};

class A
{
public:
	A(int a = 0)
		:_a(a)
	{}
private:
	int _a;
};

class Date
{
public:
	// 初始化列表是每个成员定义的地方，不管你写不写，每个成员都要会在初始化列表定义
	// 编译器对不写在初始化列表的内置类型用随机值初始化，对自定义类型会去调用其默认构造函数（可以在监视窗口看出）
	// 如果在初始化列表已经初始化，并且也在默认构造函数使用了缺省参数，那么以初始化列表的为主
	Date(int year, int month, int day, int& i)//从下面可以看出来初始化列表和在函数体里面赋值可以混合使用
		: _year(year)
		, _month(month)
		,_a(1)
		,_refi(i)
		//,_x(1)     //这句话不能写在下面的函数体，因为const修饰的变量要在定义时初始化
	{
		// 这里已经不算初始化列表了，算赋值
		_day = day;
	}

	void func()
	{
		++_refi;
		++_refi;
	}
private://注意下面的变量全部只是声明，在定义的时候是按照变量声明的顺序走的
	int _year;  
	int _month = 1;
	int _day = 1;
	// C++11支持给缺省值，这个缺省值是给初始化列表的
	// 如果初始化列表没有显式给值，就用这个缺省值
	// 如果显式给值了，就不用这个缺省值

	// 下面的变量必须在定义时初始化
	const int _x = 10;
	int& _refi;
	A _a;
};
 //能用初始化列表就用初始化列表
 //有些场景还是需要初始化列表和函数体混着用
int main()
{
	//MyQueue mq;

	int n = 0;
	Date d1(2023, 7, 28, n);
	d1.func();

	cout << n << endl;

	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
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154

二、explicit关键字、匿名对象

1. explicit关键字

  构造函数不仅可以构造与初始化对象，还具有类型转换的作用。用explicit修饰构造函数，将会禁止构造函数的隐式转换。

2. 匿名对象

以上内容在下面的代码中可以得到体现：

class A
{
public:
	explicit A(int i)//explicit关键字可以阻止单/多参数构造函数的隐式类型转换
		//A(int i)
		:_a(i)
	{
		cout << "A(int i)" << endl;
	}

	A(const A& aa)
		:_a(aa._a)
	{
		cout << "A(const A& aa)" << endl;
	}

	~A()
	{
		cout << "~A()" << endl;
	}
private:
	int _a;
};

class B
{
public:
	B(int b1, int b2)
		//explicit B(int b1, int b2)
		:_b1(b1)
		, _b2(b2)
	{
		cout << "B(int b1, int b2)" << endl;
	}
private:
	int _b1;
	int _b2;
};

struct SeqList
{
public:
	void PushBack(const A& x)
	{
		// ... 扩容
		_a[_size++] = x;
	}

	size_t size() const
	{
		return _size;
	}

	// 读
	const A& operator[](size_t i) const
	{
		assert(i < _size);

		return _a[i];
	}

	// 读/写
	A& operator[](size_t i)
	{
		assert(i < _size);

		return _a[i];
	}

private:
	// C++11
	A* _a = (A*)malloc(sizeof(A) * 10);
	size_t _size = 0;
	size_t _capacity = 0;
};

class Solution {
public:
	int Sum_Solution(int n) {
		// ...
		return n;
	}
private:
};

int main()
{
	//A aa1(1);

	//A aa2 = 2;// 单参数构造函数的隐式类型转换
	 正常的步骤是用int类型的2调用A的构造函数生成一个临时对象，再用这个对象去拷贝构造aa2
	 但是一般编译器会再优化，优化为用2直接构造 
	
	//上面的两个语句结果都是等价的，但是实现的过程不一样

	//const A& ref1 = 2;//不加上const就无法编译，因为按照上一条语句，类型转换会先生成临时对象，而临时对象具有常属性，把int类型赋值给常属性属于权限放大

	/*SeqList s;
	A aa3(3);
	s.PushBack(aa3);
    //上面的两个语句也可以被下面更加简洁的语句替代，之所以可以是因为的单参数构造函数的隐式类型转换
	s.PushBack(4);

	double d = 1.1;
	int i = d;//这个语句是对的，但是下面的语句不加上const就是错的，因为类型转换会生成临时对象，临时对象具有常属性，不加上const是权限的放大
	const int& j = d;*/

	// C++11 也支持多参数的隐式类型转换
	B bb1(1, 1);
	B bb2 = { 2, 2 };//注意要用花括号
	const B& ref2 = { 3,3 };

	// 有名对象 特点：生命周期在当前局部域，该语句结束之后还可以使用aa6
	A aa6(6);

	// 匿名对象 特点：生命周期只在这一行
	A(7);//没有其他地方可以使用这个对象，在这里调用完就直接析构了

	SeqList s;

	A aa7(7);
	s.PushBack(aa7);

	s.PushBack(A(8));//匿名对象

	Solution sl;
	sl.Sum_Solution(10);

	Solution().Sum_Solution(100);//匿名对象

	//Date d1(2023, 7, 28);
	//cout << d1;
	//cout << Date(2023, 7, 28);

	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
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136

三、static成员

1. 概念

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

2. 特性

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

四、友元

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

1. 友元函数

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

2. 友元类

友元类的所有成员函数都可以是另一个类的友元函数，都可以访问另一个类中的非公有成员。
（1）友元关系是单向的，不具有交换性。
    比如上述Time类和Date类，在Time类中声明Date类为其友元类，那么可以在Date类中直接访问Time类的私有成员变量，但想在Time类中访问Date类中私有的成员变量则不行。
（2）友元关系不能传递。
    如果C是B的友元， B是A的友元，则不能说明C时A的友元。
（3）友元关系不能继承，在继承位置再给大家详细介绍。
下面是友元类的用法，友元函数的用法也是类似的。

class Time
{
	friend class Date;	// 声明日期类为时间类的友元类，则在日期类中就直接访问Time类中的私有成员变量
public:
	Time(int hour = 0, int minute = 0, int second = 0)
		: _hour(hour)
		, _minute(minute)
		, _second(second)
	{}

private:
	int _hour;
	int _minute;
	int _second;
};

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

	void SetTimeOfDate(int hour, int minute, int second)
	{
		// 直接访问时间类私有的成员变量
		_t._hour = hour;
		_t._minute = minute;
		_t._second = second;
	}

private:
	int _year;
	int _month;
	int _day;
	Time _t;
};
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
37
38
39

五、内部类

1. 概念

  如果一个类定义在另一个类的内部，这个在里面的类就叫做内部类。内部类是一个独立的类， 它不属于外部类，更不能通过外部类的对象去访问内部类的成员。外部类对内部类没有任何优越的访问权限。
  注意：内部类就是外部类的友元类，参见友元类的定义，内部类可以通过外部类的对象参数来访问外部类中的所有成员。但是外部类不是内部类的友元。

2. 特性

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

class A
{
public:
	class B//默认B是A的友元类，所以B里面可以使用A的私有成员，但是反过来是不可以的
	{
	public:
		void FuncB()
		{
			A aa;
			aa._a = 1;
		}
	private:
		int _b;
	};

	void func()
	{
		B bb;
		//bb._b = 1;
	}

private:
	int _a;
};
int main()
{
	cout << sizeof(A) << endl;

	A aa;
	//B bb;//未加 A::
	A::B bb1;//如果内部类B不是public的话，那就不可以这样访问
	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

---

总结

  类与对象的基础知识大概就掌握这些，接下来我们会更加深入地学习并使用它们。