一、再谈构造函数

1.1 初始化列表

构造函数之前我们已经学过大部分内容，但是并没有学全，还有一个很重要的东西——初始化列表

1.1.1 初始化列表写法

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

	Date(int year, int month, int day):_year(year),_month(month),_day(day){}//Date d1(2023, 11, 9);

运行结果：

括号里也可以是数值（没有传参的情况）：

	Date():_year(2023), _month(11), _day(9){}

补充：声明给缺省值其实是给初始化列表的，但是在没显示写构造函数的情况；如果有写构造函数的话用构造函数中定义的值，构造函数没有参数或者具体数值就是随机值。（VS下随机值是0）

1.1.2 哪些成员要使用初始化列表

先总结下，再逐一分析

一定要初始化列表的成员有：
1.引用成员变量
2.const成员变量
3.没有默认构造的自定义类型成员变量

public:Date(int year, int month, int day):_year(year), _month(month), _day(day),t(year),a(5){}private:int _year;int _month;int _day;int& t;//引用成员变量const int a;//const成员变量
};

运行结果：

1️⃣使用引用有一个规定，那就是必须初始化。而在以上没有初始化是因为这些都是声明，接下来要定义这个引用成员变量，那么定义的地方在哪？就在初始化列表。

2️⃣const成员变量与引用也是一样的，在私有的区域里只是声明，要定义的话必须在初始化列表。

3️⃣上篇文章使用队列类的时候我们没有写队列类的构造函数，内置类型声明有缺省值使用缺省值，没有是随机值；自定义类型成员变量让编译器自动调用它的默认构造。

复习下什么是默认构造：
1.我们不显示写构造函数编译器默认自动生成的
2.没有传参的
3.全缺省的

如果我们要自己控制参数为多少，也就是说要传参给自定义类型的构造函数（或者自定义类型的构造函数不是默认构造，就要我们自己传参，否则我们既没有显示队列类的构造函数，也没有把它的自定义类型的构造为默认构造，结果就为随机值），就必须显示写构造函数初始化，构造函数要有初始化列表 。

总结一下：
引用成员变量和const成员变量必须要在定义的地方初始化，这个地方在初始化列表；自定义类型成员变量不写这个类的构造函数，自动调用这个自定义类型成员的默认构造；写这个类的构造函数，下面接着分析~~

1.2 初始化列表的特点

1.2.1 队列类问题解决

之前我们不写队列类的构造函数，这次就要写，构造函数里初始化自定义类型的成员变量，要用初始化列表解决。

以下代码：

class Stack
{
public:Stack(int capacity = 3){cout << "Stack(int capacity = 3)" << endl;_a = (int*)malloc(sizeof(int) * capacity);if (_a == NULL){perror("malloc fail");exit(-1);}_top = 0;_capacity = capacity;}~Stack(){cout << "~Stack()" << endl;free(_a);_a = NULL;_top = 0;_capacity = 0;}private:int* _a;int _top;int _capacity;
};
class Queue
{
public:
//   队列类的构造函数Queue():_st1(),_st2(),_size(){}
private:Stack _st1;Stack _st2;int _size;
};
int main()
{Queue q1;return 0;
}

参数是谁，有几种情况：
1️⃣只有构造函数，没有参数、括号后没有具体值
通过调试查看允许结果：

我们发现是0、3、0、3、0，所以在没有传任何值的情况下，初始化列表里对于内置类型是随机值（VS下变成0），自定义类型调用它的默认构造

2️⃣没有参数、括号后有具体值

	Queue():_st1(10), _st2(20), _size(30){}

调试结果：

3️⃣有参数为全缺省、括号后有具体值

	Queue(Stack st1 = 44, Stack st2 = 66, int size = 88):_st1(1), _st2(2), _size(3){}

调试结果：

4️⃣有参数为全缺省、括号后为参数

	Queue(Stack st1 = 44, Stack st2 = 66, int size = 88):_st1(st1), _st2(st2), _size(size){}

调试结果：

5️⃣自己传参

	Queue(Stack st1 = 44, Stack st2 = 66, int size = 88):_st1(st1), _st2(st2), _size(size){}///Queue q1(11, 77, 99);

调试结果：

6️⃣没有构造函数，声明给缺省值

private:Stack _st1 = 7;Stack _st2 = 8;int _size = 9;
};

调试结果：

总结一下：
1.当自定义类型成员的构造函数不是默认构造，有以下：
自己传参5️⃣；有参数为全缺省、括号后为参数4️⃣；有参数为全缺省、括号后有具体值3️⃣；没有参数、括号后有具体值2️⃣；声明给缺省值6️⃣。总之就是有给自定义类型成员的构造函数传参。
有具体值就用具体值，没有具体值自己传参优先，其次缺省值
为了方便控制参数，所以使用5️⃣较好。
2.当自定义类型成员的构造函数是默认构造：
只有构造函数、没有参数、没有具体值1️⃣
还有第七种7️⃣不写构造函数（上篇文章的写法）
这两种其实没有区别，所以干脆不写构造函数。

1.2.2 声明顺序是初始化列表的顺序

直接用例子展示：

class Date
{
public:Date(int year, int month, int day):_year(year), _month(month), _day(day){}void Print(){cout << _year << "-" << _month << "-" << _day << endl;}
private:int _day;//day放在最前面int _year;int _month;
};
int main()
{Date d1(2023, 11, 9);d1.Print();return 0;
}

调试结果：

所以天最先被初始化，其次是年和月。

1.3 explicit关键字

1.3.1 explicit关键字的作用

对于只有内置类型的单参数的构造函数，具有类型转换的功能
看以下代码：

class A
{
public:A(int a){_a = a;}void Print(){cout << _a << endl;}
private:int _a;
};
int main()
{A aa(1);aa = 3;aa.Print();return 0;
}

aa是自定义类型，3是整型，运行结果：

如果不想转换发生，构造函数前加explicit，此时编译器会有报错提示。

补充：加explicit关键字可以阻止隐式类型转换，但不能阻止强转。

没有使用explicit修饰，多参数且是半缺省也支持。

class Date
{
public:Date(int year, int month = 2, int day = 3){_year = year;_month = month;_day = day;}
private:int _year;int _month;int _day;
};
int main()
{Date d1 = (2023, 11, 10);return 0;
}

调试结果：

注意：小括号是逗号表达式，只算最后一个数，其他的是缺省值。

修改一下，把小括号变成花括号，并且不要缺省值：

Date d1 = { 2023, 11, 10 };

调试结果：

二、static成员

2.1 类的静态成员概念

声明为static的类成员称为类的静态成员，用static修饰的成员变量，称之为静态成员变量；用static修饰的成员函数，称之为静态成员函数。

2.2 类里创建了多少个对象问题

定义一个变量count用来计数，每创建（构造）一个对象，或者拷贝构造一个对象，count++。我们先用全局变量count来计数，看会发生什么：
1️⃣

int count = 0;
class A
{
public:A() { ++count; }A(const A& t) { ++count; }~A() {  }
private:};A Func()
{A aa;return aa;
}
int main()
{A aa;Func();cout << count << endl;return 0;
}

编译器报错了，提示count为不明确的符号，说明命名冲突了。

命名冲突的解决办法——命名空间
2️⃣

namespace yss
{int count = 0;
}
class A
{
public:A() { ++yss::count; }A(const A& t) { ++yss::count; }~A() {  }private:};A Func()
{A aa;return aa;
}
int main()
{A aa;Func();cout << yss::count << endl;return 0;
}

运行结果：

这个结果确实是我们要的答案，但是这里却有一个问题：如果再多一个类，使用全局变量就不能把两个类区分开来，导致计数完一个类再去计数另一个类count的值没有更新，也就是说两个类的对象是合并在一起的。

我们换一种方式，定义类的成员变量
3️⃣

class A
{
public:A() { ++count; }A(const A& t) { ++count; }~A() {  }//private:int count = 0;
};A Func()
{A aa;return aa;
}
int main()
{A aa;Func();cout << aa.count << endl;return 0;
}

我们暂时把私有的权限注释掉，看看运行结果如何：

为什么会是1呢？因为每创建一个对象，count+1，但是又创建一个对象，count清零再+1。说明类里一个对象一个count，而我们要的结果是类里的所有对象的个数，可是每个对象有自己的count。

要让类里的对象都是一个count怎么办，使用静态成员变量，static修饰count。
静态成员变量一定要在类外进行初始化
4️⃣

class A
{
public:A() { ++count; }A(const A& t) { ++count; }~A() {  }//private:static int count;
};
int A::count = 0;
A Func()
{A aa;return aa;
}
int main()
{A aa;Func();cout << aa.count << endl;return 0;
}

运行结果：

结果没问题了，但是，没有私有的权限，类的封装性就不能很好了。

改进：可通过一个成员函数来返回count的值
5️⃣

class A
{
public:A() { ++count; }A(const A& t) { ++count; }~A() {  }int Getcount(){return count;}
private:static int count;
};
int A::count = 0;
A Func()
{A aa;return aa;
}
int main()
{A aa;Func();cout << aa.Getcount() << endl;return 0;
}

运行结果：

但是如果我们想通过调用Func函数来计数对象创建了几个，main函数里实例化的对象不算该怎么办？

假设调用两次Func函数，先别注释对象的实例化，得到的结果应该为5

int main()
{A aa;Func();Func();cout << aa.Getcount() << endl;return 0;
}

然后把对象注释掉，发现编译器报错：未定义标识符aa。

可以使用静态成员函数来解决
6️⃣

	static int Getcount(){return count;}

注意：要通过类名::静态成员来访问

运行结果：

总结：
静态成员变量和静态成员函数与全局变量和全局函数很像，只是受作用域限定符和点成员操作符限制
补充：
静态成员函数不可以调用非静态成员函数，因为静态成员函数没有this指针； 非静态成员函数可以调用类的静态成员函数，因为它们属于同一个类。

三、友元

3.1 概念

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

友元分为：友元函数和友元类

3.2 友元函数

当一个函数不是类的成员函数，但又要能访问到类里的成员变量，必须使用友元函数

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

class Date
{
public:Date(int year, int month, int day){_year = year;_month = month;_day = day;}//友元函数friend ostream& operator<<(ostream& out, Date& d);
private:int _year;int _month;int _day;
};
ostream& operator<<(ostream& out, Date& d)
{out << d._year << "-" << d._month << "-" << d._day << endl;return out;
}
int main()
{Date d1(2023, 11, 10);cout << d1;return 0;
}

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

3.3 友元类

创建一个时间类，声明日期类为时间类的友元类，则在日期类中就直接访问Time类中的私有成员变量

class Time
{// 友元类friend class Date; 
public:Time(int hour = 2020, int minute = 6, int second = 5): _hour(hour), _minute(minute), _second(second){}private:int _hour;int _minute;int _second;
};
class Date
{
public:Date(int year = 2023, int month = 11, int day = 10): _year(year), _month(month), _day(day){}void SetTimeOfDate(int hour, int minute, int second){// 直接访问时间类私有的成员变量_t._hour = hour;_t._minute = minute;_t._second = second;Print();}void Print(){cout << _t._hour << "-" << _t._minute << "-" << _t._second << endl;}
private:int _year;int _month;int _day;Time _t;
};
int main()
{Date d1;d1.Print();return 0;
}

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

四、内部类

一个类定义在另一个类的内部，这个内部类就叫做内部类。内部类是一个独立的类，它不属于外部类，更不能通过外部类的对象去访问内部类的成员。

内部类就是外部类的友元类。内部类可以通过外部类的对象参数来访问外部类中的所有成员。但是外部类不是内部类的友元。

class A
{
public:class B{public:void Func(){cout << _a << endl;}};private:int _b;
private:static int _a;
};
int A::_a = 10;
int main()
{A::B b1;b1.Func();return 0;
}

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

五、拷贝对象时的一些编译器优化

在传参和传返回值的过程中，一般编译器会做一些优化，减少对象的拷贝。不同的编译器优化的方式可能会不同。

1️⃣隐式类型，连续构造+拷贝构造->优化为直接构造

class A
{
public:A(int a = 0):_a(a){cout << "A(int a)" << endl;}A(const A& aa):_a(aa._a){cout << "A(const A& aa)" << endl;}
private:int _a;
};
void Func(A aa)
{}
int main()
{Func(1);return 0;
}

1是整型，发生隐式类型转换通过调用构造函数产生临时变量，临时变量再拷贝给形参调用拷贝构造函数。

2️⃣一个表达式中，连续构造+拷贝构造->优化为一个构造

class A
{
public:A(int a = 0):_a(a){cout << "A(int a)" << endl;}A(const A& aa):_a(aa._a){cout << "A(const A& aa)" << endl;}
private:int _a;
};
void Func(A aa)
{}
int main()
{Func(A(1));return 0;
}

在一个表达式中，A(1)调用构造函数产生临时变量，临时变量再拷贝给形参调用拷贝构造函数，优化成一次构造。

3️⃣一个表达式中，连续拷贝构造+拷贝构造->优化一个拷贝构造

class A
{
public:A(int a = 0):_a(a){cout << "A(int a)" << endl;}A(const A& aa):_a(aa._a){cout << "A(const A& aa)" << endl;}
private:int _a;
};
A Func()
{A aa;return aa;
}
int main()
{A aa2 = Func();return 0;
}

实例化aa2调用一次构造，进入Func()函数，创建aa对象调用一次构造，两次构造优化为一次构造；局部变量拷贝给返回值调用拷贝构造，返回值拷贝给aa2再调用拷贝构造，两次拷贝构造优化成一次拷贝构造。

4️⃣一个表达式中，连续拷贝构造+赋值重载->无法优化

class A
{
public:A(int a = 0):_a(a){cout << "A(int a)" << endl;}A(const A& aa):_a(aa._a){cout << "A(const A& aa)" << endl;}
private:int _a;
};
A Func()
{A aa;return aa;
}
int main()
{A aa3;aa3 = Func();return 0;
}

实例化aa3调用构造，此时aa3已存在，调用Func()的返回值是赋值，Func()函数里创建aa对象调用构造，局部变量拷贝给返回值调用拷贝构造，最后赋值。