类和对象竟是这样的（下集）
一.初始化列表
其实大家可能会问，诶前面不是讲了有构造函数这个东西吗？为什么又要搞一个初始化列表出来。
其实根据其名字可以知道初始化列表是用来初始化的，在构造函数中，其实并不能算是初始化，只能算赋值，因为构造函数可以多次调用，而初始化只能一次。
1.列表格式
列表格式：以一个冒号开始，接着是一个个逗号隔开的成员变量，成员变量后面跟着其相应的一个放在括号里的初始值或表达式。
class Date
{
public:
Date(int year, int month, int day)
: _year(year)
, _month(month)
, _day(day)
{}
private:
int _year;
int _month;
int _day;
};2.注意事项
（1）每个成员变量在初始化列表中只能出现一次（只能初始化一次）
（2）下面几种情况的成员变量只能用初始化列表初始化：
a.引用成员变量
b.const修饰的成员变量
c.自定义类成员变量（且该类没有默认构造函数）
class A
{
public:
A（int a）
:_a(a)
{}
private:
int _a;
}
class B
{
public:
B(int a,int b)
:_obj(a)
,_b(b)
,_c(10)
private:
A _obj;//没有默认构造函数
int& _b;//引用
const int _c;//const引用
}（3）尽量使用初始化列表，因为无论你使不使用初始化列表，对于自定义类型变量，都会优先使用初始化列表
#include<iostream>
using namespace std;
class Time
{
public:
Time(int hour=0)
:_hour(hour)
{
cout << "Time()" << endl;
}
private:
int _hour;
};
class Date
{
public:
Date(int day)
{}
private:
int _day;
Time _time;
};
int main()
{
Date t(1);
}（4）成员变量声明顺序就是其在初始化列表初始化顺序，无关其在初始化列表中的顺序
下面我们来做一个小题：
class A { public: A(int a) :_a1(a) ,_a2(_a1) {} void Print() { cout_a1" "_a2endl; } private: int _a2; int _a1; }; int main() { A aa(1); aa.Print(); } A. 输出1 1 B.程序崩溃 C.编译不通过 D.输出1 随机值
答案是D
为什么呢？
因为在声明时按照的是_a2,_a1的顺序来的，而在初始化列表中是_a1,_a2的顺序来的，按照我们的说法，应该是按照生命的顺序来初始化，所以先初始化_a2，此时_a1还是随机值，所以_a2就是随机值。
3.explicit关键字
构造函数不仅可以构造与初始化对象，对于单个参数或者除第一个参数无默认值其余均有默认值 的构造函数，还具有类型转换的作用。
而加上explicit修饰后，就不能类型转换了。
二.static成员
1.概念
声明为static的类成员称为类的静态成员，用static修饰的成员变量，称之为静态成员变量；用
static修饰的成员函数，称之为静态成员函数。静态成员变量一定要在类外进行初始化。
2.特性
（1）. 静态成员为所有类对象所共享，不属于某个具体的对象，存放在静态区 （2）. 静态成员变量必须在类外定义，定义时不添加static关键字，类中只是声明 （3）. 类静态成员即可用 类名::静态成员 或者 对象.静态成员 来访问 （4）. 静态成员函数没有隐藏的this指针，不能访问任何非静态成员 （5）. 静态成员也是类的成员，受public、protected、private 访问限定符的限制 （6）.静态成员函数不可以调用非静态成员函数，非静态成员函数可以调用类的静态成员函数
三.友元
五.匿名对象
直接上代码：
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;
}六.拷贝对象时的一些编译器的优化
在传参和传返回值的过程中，一般编译器会做一些优化（不同编译器优化可能不同，只是举个普遍现象），减少对象的拷贝：
（1）.连续构造+连续构造-》优化为构造 （2）.一个表达式中，连续构造+拷贝构造-》优化为一个构造 （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;
}
A& operator=(const A& aa)
{
cout << "A& operator=(const A& aa)" << endl;
if (this != &aa)
{
_a = aa._a;
}
return *this;
}
~A()
{
cout << "~A()" << endl;
}
private:
int _a;
};
void f1(A aa)
{}
A f2()
{
A aa;
return aa;
}
int main()
{
// 传值传参
A aa1;
f1(aa1);
cout << endl;
// 传值返回
f2();
cout << endl;
// 隐式类型，连续构造+拷贝构造->优化为直接构造
f1(1);
// 一个表达式中，连续构造+拷贝构造->优化为一个构造
f1(A(2));
cout << endl;
// 一个表达式中，连续拷贝构造+拷贝构造->优化一个拷贝构造
A aa2 = f2();
cout << endl;
// 一个表达式中，连续拷贝构造+赋值重载->无法优化
aa1 = f2();
cout << endl;
return 0;
}总结
好了，到这里今天的知识就讲完了，大家有错误一点要在评论指出，我怕我一人搁这瞎bb，没人告诉我错误就寄了。
祝大家越来越好，不用关注我（疯狂暗示）
腾讯云开发者
