在之前，已经了解学习了类和对象的大部分内容；类和对象的基础内容，默认函数等等；这里我们要探讨类和对象更深入的内容，主要是初始化列表 ，各种对象，还有编译器优化等等；大家没看过之前内容的，可以浏览观看一下我之前的文章，谢谢大家支持；
再探构造函数
基本内容
- 之前我们实现构造函数时，初始化成员变量主要使⽤函数体内赋值，这里还有⼀种方式，就是初始化列表，（初始化列表的使⽤⽅式是以⼀个冒号开始，然后是⼀个以逗号分隔的数据成员列表，每个"成员变量"后⾯跟⼀个放在括号中的初始值或表达式）
- 每个成员变量在初始化列表中只能出现⼀次，语法理解上初始化列表可以认为是每个成员变量定义初始化的地⽅。
- 引⽤成员变量，const成员变量，没有默认构造的类类型变量，必须放在初始化列表位置进⾏初始化，否则会编译报错。
- C++11⽀持在成员变量声明的位置给缺省值，这个缺省值主要是给没有显⽰在初始化列表初始化的成员使⽤的。
- 初始化列表中按照成员变量在类中声明顺序进⾏初始化，跟成员在初始化列表出现的的先后顺序⽆关。建议声明顺序和初始化列表顺序保持⼀致。
代码参考及扩展
1, 2,
class Date1
{
public:
Date1(int year = 1, int month = 1, int day = 1)
:_year(year)
, _day(day)
, _month(month)
{}
void printf()
{
cout << "年" << _year << "月" << _month << "日" << _day << endl;
}
private:
int _year;
int _month;
int _day;
};
class Date2
{
public:
Date2(int year = 1, int month = 1, int day = 1)
:_year(year)
//这里初始化列表定义了，但没有给值，
//内置类型则是 编译器不管 随机值 或 0 ； 自定义类型则是 调用 自己的构造函数
,_month()
{}
void printf()
{
cout << "年" << _year << "月" << _month << "日" << _day << endl;
}
private:
//初始化列表没有定义时，就用声明这的缺省函数
int _year = 10;
int _month = 10;
int _day = 10;
};
int main()
{
Date1 d1;
d1.printf();
Date2 d2;
d2.printf();
return 0;
}通过运行则能证明：
总结
每个成员都要走初始化列表，则分为：
1 有在初始化列表定义的成员
2 没有在初始化列表定义的成员则： （没显示写）
A 声明地方的缺省值有则用
B 声明的地方没有缺省值则：
X 内置类型 看编译器 大概率是随机值
Y 自定义类型 调用默认构造 没有编译报错
3,
class Date
{
public:
Date(int& xx)
:_month(2)
,_n(1)
,_t(1)
,_p(xx)
,_ptr((int*)malloc(12))
{
//_ptr = (int*)malloc(12);
if (_ptr == nullptr)
{
perror("malloc fail");
}
else
{
//随便设置一下内存
memset(_ptr, 0, 12);
}
}
void Print() const
{
cout << _year << "-" << _month << "-" << _day << endl;
}
private:
// 注意这⾥不是初始化，这⾥给的是缺省值，这个缺省值是给初始化列表的
// 如果初始化列表没有显⽰初始化，默认就会⽤这个缺省值初始化
int _year = 1;
int _month = 1;
int _day;
Time _t;
const int _n ;
int& _p;
int* _ptr;
};
int main()
{
int x = 0;
Date d(x);
d.Print();
return 0;
}Const， 引用常量 ，无默认构造的自定义类类型 必须用初始化列表
4,
初始化的顺序 的按照 声明 的顺序
本质：内存的地址 就是按声明的顺序放的 初始化也是按照这个地址来的
如图 a2 地址是第一个 a1 地址是第二个 （代码在下面一个图）
5，
此代码可以完美解释
注意事项：
尽量使⽤初始化列表初始化，因为那些你不在初始化列表初始化的成员也会⾛初始化列表，如果这个成员在声明位置给了缺省值，初始化列表会⽤这个缺省值初始化。如果你没有给缺省值，对于没有显⽰在初始化列表初始化的内置类型成员是否初始化取决于编译器，C++并没有规定。对于没有显⽰在初始化列表初始化的⾃定义类型成员会调⽤这个成员类型的默认构造函数，如果没有默认构造会编译错误。
类型转换
基本内容
- C++⽀持内置类型隐式类型转换为类类型对象，需要有相关内置类型为参数的构造函数、
- 构造函数前⾯加explicit就不再⽀持隐式类型转换
代码参考既解释
1,
什么是隐式类型转换，就是用 1（数字） 或其他内置类型构造一个类类型的临时对象；再用这个临时对象拷贝构造类类型，
如代码所示
class A
{
public:
A(int a)
:_a1(a)
,_a2(a)
{}
A(int a1, int a2)
:_a1(a1)
,_a2(a2)
{}
void Print() {
cout << _a1 << " " << _a2 << endl;
}
private:
int _a1 = 2;
int _a2;
};
int main()
{
A aa(1);
//1构造⼀个A的临时对象，再⽤这个临时对象拷⻉构造aa3
//不同编译会有不同的优化，一般为 连续构造+拷⻉构造->优化为直接构造
A aa1 = 1;
aa1.Print();
//引用对象是常性 所以要加const 防止权限扩大
const A& aa2 = 1;
//c++11也支持多参数转换的隐式类型转换
A aa3 = { 1, 2 };
aa3.Print();
}其中优化部分在后面会仔细说明，这里可以先了解一下
扩展：有人许有这样的疑问（会不会_a2 调用 _a1 时会编译因为 _a1 未开辟空间 而终止？）
不存在 _a2 调用_a1 时 a1 没有空间
构造函数 不是开空间的，仅仅只是初始化；
实例化的时候开空间 也就是 调用那个函数 (A aa1 = 1;) 的同时就开了空间
2，
如图所示，加explicit 就不能进行隐式类型转换
static成员
基本内容
- ⽤static修饰的成员变量，称之为静态成员变量，静态成员变量⼀定要在类外进⾏初始化。静态成员变量不能在声明位置给缺省值初始化，因为缺省值是个构造函数初始化列表的，静态成员变量不属于某个对象，不⾛构造函数初始化列表。
- 静态成员变量为所有类对象所共享，不属于某个具体的对象，不存在对象中，存放在静态区。
- ⽤static修饰的成员函数，称之为静态成员函数，静态成员函数没有this指针。
- 静态成员函数中可以访问其他的静态成员，但是不能访问⾮静态的，因为没有this指针。
- ⾮静态的成员函数，可以访问任意的静态成员变量和静态成员函数。
- 突破类域就可以访问静态成员，可以通过类名::静态成员 或者 对象.静态成员 来访问静态成员变量和静态成员函数，但是静态成员也是类的成员，受public、protected、private 访问限定符的限制。
参考代码既解释
class A
{
public:
A()
{
++_scount;
}
A(const A& t)
{
++_scount;
}
~A()
{
--_scount;
}
static int GetACount()
{
return _scount;
}
private:
// 类⾥⾯声明
static int _scount;
};
// 类外⾯初始化
int A::_scount = 0;
class A2 {
public:
int sum() {
return A::GetACount();
}
};
int main()
{
cout << A::GetACount() << endl;
A a1, a2;
A a3(a1);
cout << A::GetACount() << endl;
cout << a1.GetACount() << endl;
cout << A2().sum() << endl;
// 编译报错：error C2248: “A::_scount”: ⽆法访问 private 成员(在“A”类中声明)
//cout << A::_scount << endl;
return 0;
}以上代码即可验证 1，2,3,4,5,6
静态成员 局部成员 与 全局成员 构造 与 析构 的 规则
设已经有A,B,C,D 4个类的定义，程序中A,B,C,D构造函数调⽤顺序为？（）
设已经有A,B,C,D 4个类的定义，程序中A,B,C,D析构函数调⽤顺序为？（）
A：D B A C B：B A D C C：C D B A D ：A B D C E：C A B D F：C D A B
C c;
int main()
{
A a;
B b;
static D d;
return 0；
}对于构造函数 先全局 在局部 对于静态位置在哪里就在开始
对应析构函数 先析构全局生命周期 再局部生命周期 两者都是就近原则 （谁离结束近谁先析构）
友元
基本内容
- 友元提供了⼀种突破类访问限定符封装的⽅式，友元分为：友元函数和友元类，在函数声明或者类声明的前⾯加friend，并且把友元声明放到⼀个类的⾥⾯。而且友元函数可以在类定义的任何地⽅声明，不受类访问限定符限制。
- 外部友元函数可访问类的私有和保护成员，友元函数仅仅是⼀种声明，他不是类的成员函数。
- 友元类中的成员函数都可以是另⼀个类的友元函数，都可以访问另⼀个类中的私有和保护成员。
- ⼀个函数可以是多个类的友元函数。
- 友元类的关系是单向的，不具有交换性，⽐如A类是B类的友元，但是B类不是A类的友元；友元类关系不能传递，如果A是B的友元， B是C的友元，但是A不是B的友元。
- 虽然有时提供了便利。但是友元会增加耦合度，破坏了封装，切记友元不宜多⽤。
代码参考和解释
1，2，3，4
//这个前置声明，主要是让A中的友园函数的参数 认识类型B
class B;
class A
{
// 友元声明
friend void func(const A& aa, const B& bb);
private:
int _a1 = 1;
int _a2 = 2;
};
class B
{
// 友元声明
friend void func(const A& aa, const B& bb);
private:
int _b1 = 3;
int _b2 = 4;
};
void func(const A& aa, const B& bb)
{
cout << aa._a1 << endl;
cout << bb._b1 << endl;
}
int main()
{
A aa;
B bb;
func(aa, bb);
return 0;
}这里需要注意的就是前置声明，在编译到友元函数时，编译器是从次处向上寻找，若没有前置声明编译器找不到B，则就会报错。
总结：用任何的类型都要向上找 前置声明 ，如友元函数 的定义
6
我们都知道⾯向对象三⼤特性：封装、继承、多态。
若过多使用这个，会破坏 封装的特性。
内部类
基本内容
- 如果⼀个类定义在另⼀个类的内部，这个内部类就叫做内部类。内部类是⼀个独⽴的类，跟定义在 全局相⽐，他只是受外部类类域限制和访问限定符限制，所以外部类定义的对象中不包含内部类。
- 内部类默认是外部类的友元类。
- 内部类本质也是⼀种封装，当A类跟B类紧密关联，A类实现出来主要就是给B类使⽤，那么可以设计A类为B的内部类，如果放到private/protected位置，那么A类就是B类的专属内部类，其他地⽅⽤不了。public则能通过 :: 使用
解释
这里就没什么好说的；直接用一个题目表示吧
参考代码：
这里这个也行满足要求，但是作为这道题，是不对的
此外，这里还用到了变长数字 如 A sum[n]如果有编译器不支持这个的话，就只能用new平替：A* sum = new A[n]; (VS 就不支持）
匿名对象
基本内容
- ⽤ 类型(实参) 定义出来的对象叫做匿名对象，相⽐之前我们定义的 类型 对象名(实参) 定义出来的叫有名对象
- 匿名对象⽣命周期只在当前⼀⾏，⼀般临时定义⼀个对象当前⽤⼀下即可，就可以定义匿名对象
代码参考和解释
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(1);
A aa2(2);
// 匿名对象在这样场景下就很好⽤，当然还有⼀些其他使⽤场景，这里就不在展示
//在方便的同时也 增加了效率；
Solution().Sum_Solution(10);
cout << "########" << endl;
return 0;
}记住一点就行，匿名代码，生命周期只有哪一行，用完就要析构
对象拷⻉时的编译器优化
基本内容
- 现代编译器会为了尽可能提⾼程序的效率，在不影响正确性的情况下会尽可能减少⼀些传参和传参过程中可以省略的拷⻉。（如上面有一个连续构造+拷⻉构造->优化为直接构造）
- 如何优化C++标准并没有严格规定，各个编译器会根据情况⾃⾏处理。当前主流的相对新⼀点的编译器对于连续⼀个表达式步骤中的连续拷⻉会进⾏合并优化，有些更新更"激进"的编译还会进行跨行跨表达式的合并优化。
以VS2019 为例
在debug 版本中 原本 使用函数情况 因如 左图所示 但是 编译器 编译起来却是 右图；
这就是编译器优化，将两个拷贝优化为了一个；而且这个构造还是给临时变量的构造 原因如图
如图 可以看见析构是在 return aa； 之后完成的，所以这个构造还是给临时变量的构造；
这就是编译器的优化，了解就好；
此外 在 realse 或者 更高的版本中 优化力度会更大 更激进；
1万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
