一，再谈构造函数

这个语法其实是对前面的构造函数的补充。最重要的是初始化列表的使用，及其特性，隐式类型转换，还有当前阶段需要了解的 explicit 关键字。

1.初始化列表

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

1.1 初始化列表的使用

当我们实现一个MyQueue(用两个栈模拟一个队列)时，如果栈不具备默认构造，MyQueue也无法生成默认构造，此时MyQueue要显示实现默认构造。

如何实现呢？必须用初始化列表。

初始化列表的本质：可以理解为每个对象中成员定义的地方。

typedef int DataType;
class Stack
{
public:Stack(size_t capacity ){_array = (DataType*)malloc(sizeof(DataType) * capacity);if (NULL == _array){perror("malloc申请空间失败!!!");return;}_capacity = capacity;_size = 0;}void Push(DataType data){// CheckCapacity();_array[_size] = data;_size++;}~Stack(){if (_array){free(_array);_array = NULL;_capacity = 0;_size = 0;}}private:DataType* _array;int _capacity;int _size;
};class MyQueue
{
public://初始化列表MyQueue(int n= 20):_pushst(n)//自定义类型会调用构造函数, _popst(n)//, _size(0) //ok{//函数体内_size = 0;//ok}
private://声明Stack _pushst;Stack _popst;int _size;
};int main()
{MyQueue q1(10);MyQueue q2;//有缺省值时可以不用赋值，没传默认用缺省值return 0;
}

1.2 有些变量只能在初始化列表中初始化，不能在函数体中初始化。
(1) const 成员变量；
const 成员变量必须在定义的地方初始化，因为它只有一次初始化机会。或是在声明时用缺省值。

(2) 引用成员变量；
引用也必须在定义的时候初始化。

(3) 没有默认构造的自定义类型成员。
因为没有默认构造时，必须显式传参调用构造函数。

class MyQueue
{
public:MyQueue(int n,int& rr)//这里也可以写缺省值:_pushst(n)//自定义类型会调用构造函数, _popst(n)//, _size(0) //ok,_x (1),_ref(rr){//函数体内_size = 0;//ok//_x =1; //err}
private://声明Stack _pushst;Stack _popst;int _size;//const变量必须在定义的时候初始化。因为它只有一次初始化的机会const int _x;const int _x = 10;//在这里给缺省值ok//引用变量必须在定义的时候初始化int& _ref;
};int main()
{int xx = 0;MyQueue q1(10,xx);MyQueue q1(10);int& aa = xx;return 0;
}

1.3 初始化列表，不管你写不写，每个成员变量都会先走一遍，此时自定义类型的成员会调用默认构造(没有默认构造就编译报错)，内置类型看编译器，有点会处理，有的不会处理。

1.4 在C11中我们知道可以在成员变量声明时给缺省值，实际上这个缺省值就是给初始化列表用的。但是与此同时，如果在初始化列表中给定了值，就以列表中的为准，与缺省值无关。

class MyQueue
{
public://实践总结：尽可能使用初始化列表初始化，不方便再使用函数体初始化MyQueue():_pushst(10),_ptr((int*)malloc(40)) //ok{_size = 2;}private://声明Stack _pushst;Stack _popst;//这里的缺省值是1，但是初始化列表中是2，此时_size = 2int _size = 1;int* _ptr;
};

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

比如下面的代码，运行结果是：1 ，随机值。

这是因为先声明的是_a2 ，所以在初始化时会先走_a2(_a1)这条语句，而此时_a1没有初始化，是随机值，所以_a2是随机值。再初始化_a1。

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();
}

2. 隐式类型转换的过程及其优化

隐式类型转换：把内置类型转换为自定义类型。

优化：在一个表达式中，编译器遇到构造 + 拷贝构造时，会优化成直接构造。

class A
{
public://单参数构造函数A(int a):_a(a){cout << "A(int a)" << endl;}//拷贝构造A(const A& aa):_a(aa._a){cout << "A(const A& aa)" << endl;}private:int _a;
};int main()
{A aa1(1);//拷贝构造A aa2 = aa1;//ok//过程：先用3构造了一个A的临时对象，再用临时对象去拷贝构造给aa3//优化：在一个表达式中，编译器遇到构造 + 拷贝构造，会优化成直接构造A aa3 = 3;//A& raa = 4;//err//当用引用时，由于用3构造了一个临时对象，临时对象具有常性，所以加const//过程：这里只用3构造了一个临时对象，没有拷贝构造//raa引用的是类型转换中用3构造的临时对象const A& raa = 4;//okreturn 0;
}

3. 隐式类型转换的使用

在C++初阶，隐式转换使用的较少，但是在以后是很有用的，使用起来很方便，简洁。

class A
{
public:A(int a):_a1(a), _a2(_a1){}void Print(){cout << _a1 << " " << _a2 << endl;}
private:int _a2;int _a1;
};class Stack
{
public://方式1：ok//void Push(A& aa)//{//	//.......//}	//方式2：okvoid Push(const A& aa){//....}//.....
};int main()
{Stack st;//方式1：会进行先构造，后拷贝构造A a1(1);st.Push(a1);//方式2：10进行了隐式类型转换，时代码更简洁st.Push(10);return 0;
}

4. explcit关键字

作用：禁止构造函数的隐式转换。

看看下面的代码，如果在构造函数前加上explcit，运行结果：

class A
{
public://单参数构造函数explicit A(int a)//A(int a):_a(a){cout << "A(int a)" << endl;}//拷贝构造A(const A& aa):_a(aa._a){cout << "A(const A& aa)" << endl;}private:int _a;
};int main()
{A aa1(1);//拷贝构造A aa2 = aa1;A aa3 = 3;const A& raa = 4;return 0;
}

5. 单参数和多参数构造函数的隐式类型转换

多参数构造函数的隐式类型转换的过程与第2点中解释的单参数类似。

class A
{
public://单参数构造函数//explicit A(int a)A(int a):_a(a){cout << "A(int a)" << endl;}//多参数构造函数A (int a1,int a2):_a(0),_a1(a1),_a2(a2){}//拷贝构造A(const A& aa):_a(aa._a){cout << "A(const A& aa)" << endl;}private:int _a;int _a1;int _a2;
};int main()
{A aaa1(1, 2);A aaa2 = { 1,2 };//传参时要用花括号const A& aaa3 = { 3,2 };return 0;
}

二，static成员

对象中只存成员变量，不存静态成员变量，静态成员变量在静态区，也不存函数，函数指针，它们在代码段。

1.静态成员变量

特性：
(1) 静态成员变量在静态区，不在对象中；
(2) 静态成员变量不能给缺省值，因为缺省值是给初始化列表用的，它在静态区，不在对象中，不走初始化列表；
(3) 静态成员变量的定义在全局，如果只有声明，没有定义，会报错！

当用sizeof计算对象的大小时，结果是：8
这就说明 aa1 对象中只有_a1，_a2，没有 _scount。

class A
{
public:A(){cout << "A()" << endl;}A(const A& t){cout << "A(const A& t)" << endl;}~A(){cout << "~A()" << endl;}
private://声明int _a1;int _a2;public://在静态区，不在对象中//不能给缺省值，因为缺省值是给初始化列表用的//它在静态区，不在对象中，不走初始化列表static int _scount;
};//静态成员变量的定义(如果只有声明，没有定义，会报错！)
int A::_scount = 1;int main()
{A aa1;cout << sizeof(aa1) << endl;//8//如果它是公有的，就可以按如下访问//aa1._scount++;//cout << A::_scount << endl;return 0;
}

静态成员变量的特点：它属于整个类，属于所有对象。

使用静态成员变量可以统计一共创建了多少个类对象：

因为所有的对象都要走构造或者拷贝构造：在它们之中++，统计累计创建了多少个类对象；
当走完析构函数：统计现在还有多少对象存活。

代码实现如下：

class A
{
public:A(){++_scount;}A(const A& t){++_scount;}~A(){--_scount;}private://声明int _a1;int _a2;public:static int _scount;
};int A::_scount = 0;int main()
{A aa1;//cout << sizeof(aa1) << endl;//8A aa2;A aa3;cout << A::_scount << endl;return 0;
}

2.静态成员函数

第1点中对静态变量的使用都是它在公有的前提下，那么它在私有时该如何访问呢？就要使用静态成员函数了。

特点：static修饰成员函数，没有this指针，意味着只能访问静态成员，不能访问其他的成员变量。

class A
{
public:A(){++_scount;}A(const A& t){//但是非静态的可以调用静态的GetCount();//ok++_scount;}~A(){--_scount;}//特点：static修饰成员函数，没有this指针，意味着只能访问静态成员//不能访问其他的成员变量static int GetCount(){return _scount;}private://声明int _a1;int _a2;static int _scount;
};int A::_scount = 0;int main()
{A aa1;A aa2;A aa3;//调用方式cout << A::GetCount() << endl;return 0;
}

三，友元

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

3.1 友元函数

问题：
现在尝试去重载operator<<，然后发现没办法将operator<<重载成成员函数。

原因：

• 因为cout的输出流对象和隐含的this指针在抢占第一个参数的位置。this指针默认是第一个参数也就是左操作数了。但是实际使用中cout需要是第一个形参对象，才能正常使用。所以要将operator<<重载成全局函数。但又会导致类外没办法访问成员，此时就需要友元来解决。operator>>同理。

class Date
{
public:Date(int year, int month, int day): _year(year), _month(month), _day(day){}// d1 << cout; -> d1.operator<<(&d1, cout); 不符合常规调用// 因为成员函数第一个参数一定是隐藏的this，所以d1必须放在<<的左侧ostream& operator<<(ostream& _cout){_cout << _year << "-" << _month << "-" << _day << endl;return _cout;}
private:int _year;int _month;int _day;
};

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

class Date
{//友元函数的声明friend ostream& operator<<(ostream& _cout, const Date& d);friend istream& operator>>(istream& _cin, Date& d);public:Date(int year = 1900, int month = 1, int day = 1): _year(year), _month(month), _day(day){}
private:int _year;int _month;int _day;
};ostream& operator<<(ostream& _cout, const Date& d)
{_cout << d._year << "-" << d._month << "-" << d._day;return _cout; 
}istream& operator>>(istream& _cin, Date& d)
{_cin >> d._year;_cin >> d._month;_cin >> d._day;return _cin;
}int main()
{Date d;cin >> d;cout << d << endl;return 0;
}

说明:

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

3.2 友元类

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

class Time
{//声明 Date是Time的友元//则在Date中可以访问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
{
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. 友元关系是单向的，不具有交换性；
   比如上述Time类和Date类，在Time类中声明Date类为其友元类，那么可以在Date类中直接
   访问Time类的私有成员变量，但想在Time类中访问Date类中私有的成员变量则不行。
2. 友元关系不能传递；
   如果C是B的友元， B是A的友元，则不能说明C时A的友元。
3. 友元关系不能继承，在继承位置再给大家详细介绍。

四，内部类

概念：如果一个类定义在另一个类的内部，这个内部类就叫做内部类。

内部类是一个独立的类，它不属于外部类，它仅仅是受到外部类域的限制，更不能通过外部类的对象去访问内部类的成员。外部类对内部类没有任何优越的访问权限。

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

class A
{
private:static int k;int h;
public:class B // B天生就是A的友元{public:void foo(const A& a){cout << k << endl;//OKcout << a.h << endl;//OK}};};int A::k = 1;int main()
{A::B b;b.foo(A());return 0;
}

特性：

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

五，匿名对象

匿名对象的生命周期只在当前这一行，即用即销毁。

class A
{
public:A(int a = 0):_a(a){cout << "A(int a)" << endl;}~A(){cout << "~A()" << endl;}
private:int _a;};class Solution {
public:int Sum_Solution(int n) {//...return n;}
};int main()
{A aa1;// 不能这么定义对象，因为编译器无法识别下面是一个函数声明，还是对象定义//A aa1();// 但是我们可以这么定义匿名对象，匿名对象的特点不用取名字，// 但是他的生命周期只有这一行，我们可以看到下一行他就会自动调用析构函数A();A aa2(2);// 匿名对象在这样场景下就很好用，当然还有一些其他使用场景，这个我们以后遇到了再说Solution().Sum_Solution(10);return 0;
}