[ C++ ] 类与对象(下) 初始化列表，友元，static成员，内部类

得意犹堪夸世俗，诏黄新湿字如鸦。这篇文章主要讲述[ C++ ] 类与对象(下) 初始化列表，友元，static成员，内部类相关的知识，希望能为你提供帮助。
本篇是C++类与对象最后的部分知识，主要是对类的更深层次理解和使用。
1.再谈构造函数1.1 构造函数体赋值在之前我们讨论过，类会默认生成构造函数，我们把构造函数也叫做初始化函数。所以在创建对象时，编译器通过调用构造函数给对象中各个成员变量一个合适的初始值。

class Date

public:
Date(int year = 1 , int month = 1, int day = 1)

_year = year;
_month = month;
_day = day;

private:
//声明
int _year;
int _month;
int _day;
;

int main()

//对象
Date d1(2022, 5, 22);
Date d2; //未定义无参的默认构造写成全缺省就ok
return 0;

我们如果未定义无参的构造函数，尽量将构造函数写成全缺省的，这样即使有无参的对象也可以使用构造函数，否则就会报错：不存在默认构造函数。

除了这种初始化方式之外，还有一种方式是通过初始化列表进行初始化。
1.2 初始化列表

初始化列表：以一个冒号开始，接着是一个以逗号分隔的数据成员列表，每个"成员变量"后面跟一个放在括号中的初始值或表达式。

例如：我们上面的Date类用初始化列表初始化如下

class Date

public:

//初始化列表
Date(int year = 1, int month = 1, int day = 1)
:_year(year)
,_month(month)
,_day(day)

private:
//声明
int _year;
int _month;
int _day;
;

int main()

//对象
Date d1(2022, 5, 22);
Date d2;
return 0;

1.2.1初始化列表的价值：
1.初始化列表是对象的成员定义的地方。
有些成员必须在定义的地方初始化，那么那些成员必须在定义是初始化呢？
(a) 引用成员变量（b）const成员变量（c）自定义类型（无默认构造函数）

class A

public:
A(int a)
:_a(a)

private:
int _a;
;

class Date

public:

//只能在初始化列表初始化
Date(int year, int n, int ref,int a)
:_n(n)
,_ref(ref)
,_aa(a)

_year = year;

private:
//声明
//可以在定义时初始化; 也可以定义时不初始化，后面再赋值修改
int _year;

//只能在定义的时候初始化
const int _n;
int& _ref;
A _aa;
;

注意：
1. 每个成员变量在初始化列表中只能出现一次(初始化只能初始化一次)
?
2. 类中包含以下成员，必须放在初始化列表位置进行初始化：
（a）引用成员变量（b）const成员变量（c）自定义类型成员(该类没有默认构造函数)
?
3. 尽量使用初始化列表初始化，因为不管你是否使用初始化列表，对于自定义类型成员变量，一定会先使用初始化列表初始化。
?
4. 成员变量在类中声明次序就是其在初始化列表中的初始化顺序，与其在初始化列表中的先后次序无关。

1.3 explicit关键字构造函数不仅可以构造与初始化对象，对于单个参数的构造函数，还具有类型转换的作用。

class Date

public:
Date(int year)
:_year(year)

cout < < "Date(int year)" < < endl;

Date(const Date& d)

cout < < "Date(const Date& d)" < < endl;

private:
int _year;
;

int main()

Date d1(2022); //构造
//隐士类型的抓换
Date d2 = 2022; //构造+拷贝构造 -》优化

return 0;

我们可以发现2022是int类型，而d2是Date类型，因此这里发生了隐式转换。如果不想发生类型转换在构造函数前加上explicit即可。

class Date

public:
explicit Date(int year)
:_year(year)

cout < < "Date(int year)" < < endl;

private:
int _year;
;

int main()

Date d1(2022); //构造
//隐士类型的抓换
Date d2 = 2022; //构造+拷贝构造 -》优化

return 0;

此时就会发生错误：

上述代码可读性不是很好，用explicit修饰构造函数，将会禁止单参构造函数的隐式转换。
2.static成员2.1问题的引入

Q：统计A类型创造了多少个？

方法一：全局变量（不提倡）

//全局变量-- 不提倡
int num = 0;
class A

;
A Func(A a)

A copy(a);
return copy;

int main()

A a1;
A a2 = Func(a1);

cout < < num < < endl;

这里我们直接判断来找很麻烦，而且也不好找。
因此我们可以在A类中把通过构造的和通过拷贝的分别记录打印就好了，我们分别用不同的两个变量来进行记录

int num1 = 0;
int num2 = 0;
class A

public:
A()

++num1;

A(const A& aa)

++num2;

;
A Func(A a)

A copy(a);
return copy;

int main()

A a1;
A a2 = Func(a1);

cout < < num1 < < endl;
cout < < num2 < < endl;

注意：全局变量在一些简单的程序中不会有问题，但是在项目中可能会出现错误。如果在.h中定义，就有可能发生链接错误。并且放成全局也不利于封装性。
方法二：静态成员变量

class A

public:
A()

++_count1;

A(const A& aa)

++_count2;

//静态成员变量属于整个类
static int _count1; //声明
static int _count2;

int _a;

;
A Func(A a)

A copy(a);
return copy;

//定义
int A::_count1 = 0;
int A::_count2 = 0;

int main()

A a1;
A a2 = Func(a1);
cout < < sizeof(a1) < < endl;

cout < < a1._count1 < < endl;
cout < < a2._count1 < < endl;

cout < < a1._count2 < < endl;
cout < < a2._count2 < < endl;

cout < < A::_count1 < < endl;
cout < < A::_count1 < < endl;

return 0;

这里我们发现sizeof这个类，计算大小是不会计算静态成员的。因为静态成员为所有类对象所共享(在静态区)，不属于某个具体的实例，所以不会纳入类内的计算。
其次：在类内静态成员只是声明，静态成员变量必须在类外定义，定义时不添加static关键字。
如果静态成员是私有的就需要Get（）函数提供接口来访问

class A

public:
A()

++_count1;

A(const A& aa)

++_count2;

intGetCount1()

return _count1;

intGetCount2()

return _count2;

private:

static int _count1; //声明
static int _count2;

int _a;

;
A Func(A a)

A copy(a);
return copy;

//定义
int A::_count1 = 0;
int A::_count2 = 0;

int main()

A a1;
A a2 = Func(a1);

cout < < a1.GetCount1() < < endl;
cout < < a2.GetCount2() < < endl;

return 0;

我们要使用对象调用Get()函数，那假如没有对象，我们可以把函数写成静态成员函数

class A

public:
A()

++_count1;

A(const A& aa)

++_count2;

//成员函数也可以是静态的
static intGetCount1()

return _count1;

static intGetCount2()

return _count2;

private:
//静态成员变量属于整个类
static int _count1; //声明
static int _count2;

int _a;

;
A Func(A a)

A copy(a);
return copy;

//定义
int A::_count1 = 0;
int A::_count2 = 0;

int main()

A a1;
A a2 = Func(a1);

cout < < a1.GetCount1() < < endl;
cout < < a2.GetCount2() < < endl;

cout < < A::GetCount1() < < endl;
cout < < A::GetCount2() < < endl;

return 0;

但是需要注意的是static成员函数没有this指针，因此不能访问非静态成员

2.2特性

1. 静态成员为所有类对象所共享，不属于某个具体的实例。2. 静态成员变量必须在类外定义，定义时不添加static关键字。3. 类静态成员即可用类名::静态成员或者对象.静态成员来访问。4. 静态成员函数没有隐藏的this指针，不能访问任何非静态成员。5. 静态成员和类的普通成员一样，也有public、protected、private3种访问级别，也可以具有返回值。

3.C++11 的成员初始化新玩法。C++11支持非静态成员变量在声明时进行初始化赋值，但是要注意这里不是初始化，这里是给声明的成员变量缺省值。

class B

public:
B(int b = 0)
:_b(b)

private:
int _b;
;
class A

public:

private:
//非静态成员变量，可以在成员声明时给缺省值
int a = 10;
B b = 20; //隐士类型转换
int* p = (int*)malloc(4);
;

注意：静态成员不能在此赋值，因为静态成员不会在初始化列表初始化。
4. 友元友元分为：友元函数和友元类
友元提供了一种突破封装的方式，有时提供了便利。但是友元会增加耦合度，破坏了封装，所以友元不宜多用。
4.1友元函数在上一篇文章中我们其实已经提前使用了一下友元函数。那么现在我们再来重温一遍友元函数的用法和注意事项吧。
友元函数可以直接访问类的私有成员，它是定义在类外部的普通函数，不属于任何类，但需要在类的内部声明，声明时需要加friend关键字。

class Date

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

private:
int _year;
int _month;
int _day;
;
ostream& operator< < (ostream& out, const Date& d)

out < < d._year < < "-" < < d._month < < "-" < < d._day < < endl;
return out;

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

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

//友元
class Date; //Date类的声明

class Time

//友元类
friend class Date;
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

友元函数
friend ostream& operator< < (ostream& out, const Date& d);
public:

要访问Time类内的成员，使用友元类
void SetDateTime(int hour,int minute,int second)

_t._hour = hour;
_t._minute = minute;
_t._second = second;

private:
int _year;
int _month;
int _day;

Time _t;
;
ostream& operator< < (ostream& out, const Date& d)

out < < d._year < < "-" < < d._month < < "-" < < d._day < < endl;
return out;

我们发现如果我们需要在Date类内要访问Time类内的成员，就要使用友元类。

注意：
1.友元关系是单向的，不具有交换性。比如上述Time类和Date类，在Time类中声明Date类为其友元类，那么可以在Date类中直接访问Time类的私有成员变量，但想在Time类中访问Date类中私有的成员变量则不行。
2.友元关系不能传递如果B是A的友元，C是B的友元，则不能说明C时A的友元。

5.内部类5.1概念及特性

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

class A

private:
static int k;
int h;
public:

//内部类
class B

public:

private:
int _b;
;
;
int main()

A aa; //只有A的成员
cout < < sizeof(A) < < endl;
return 0;

如这段代码，我们在类A中定义了内部类B。我们sizeof（A）发现只有A自己的成员。
因此：sizeof(外部类)=外部类，和内部类没有任何关系。
?
此外，内部类天生就是外部类的友元.
内部类就是外部类的友元类。注意友元类的定义，内部类可以通过外部类的对象参数来访问外部类中的所有成员。但是外部类不是内部类的友元。

class A

private:
static int k;
int h;
public:
//内部类
class B//B天生是A的有友元

public:
void foo(const A& a)

cout < < k < < endl;
cout < < a.h < < endl;

private:
int _b;
;
;

外部类不是内部类的友元

class A

private:
static int k;
int h;
public:
//内部类
class B//B天生是A的有友元

public:
void foo(const A& a)

cout < < k < < endl;
cout < < a.h < < endl;

private:
int _b;
;
void Print(const B& b)

b._b; //访问不到

;