天空没有极限，我们的的未来无边！破茧的我会飞翔C++更蔚蓝的明天！
前言
类和对象这次就是最后一篇了，也要告别了，但之前的知识学会了吗？细节多，繁杂需要我们好好去复习思考！
一、初始化列表
1.什么是初始化列表
类的初始化分为 在内部的初始化 和 初始化列表。
对于类，我们要初始化类的成员变量，就需要定义一个对象，这叫做对象实例化，是对象的整体定义。那么要对 对象中的每个成员变量定义初始化的话，就要走初始化列表，并且所有成员变量都要先走初始化列表！
初始化列表：以一个冒号开始，接着是一个以逗号分隔的数据成员列表，每个**"成员变量"后面跟一个放在括号中的初始值或表达式。 **
初始化列表在构造函数的函数头 和 实现{}的之间，并且成员变量在初始化列表只能出现一次。
日期类：
class Date
{
public:
Date(int year, int month, int day)
: _year(year)
, _month(month)
, _day(day)
{}
private:
int _year;
int _month;
int _day;
};
1.所有成员变量初始化都要先走初始化列表
对于内置类型，如果没有显示的初始化列表，就会用随机值，有显示的初始化列表，则按照初始化列表进行初始化。
对于自定义类型，如果没有显示初始化列表，那么就会调用它的默认构造函数，这个过程都是发生在初始化列表中！
2.初始化列表和函数体内的初始化可以混着来：（但只有初始化列表不能解决的问题）
栈类：
class Stack
{
public:
/*Stack(int capacity = 4)
:_a((int*)malloc(sizeof(int)*capacity))
, _top(0)
, _capacity(capacity)
{
if (_a == nullptr)
{
perror("malloc fail");
exit(-1);
}
}*/
// 初始化列表和函数体内初始化可以混着来
Stack(int capacity = 4)
: _top(0)
, _capacity(capacity)
{
_a = (int*)malloc(sizeof(int)*capacity);
if (_a == nullptr)
{
perror("malloc fail");
exit(-1);
}
memset(_a, 0, sizeof(int)*capacity);
}
~Stack()
{
cout << "~Stack()" << endl;
free(_a);
_a = nullptr;
_top = _capacity = 0;
}
void Push(int x)
{
// ....
// 扩容
_a[_top++] = x;
}
private:
int* _a; // 声明
int _top;
int _capacity;
};
Stack(int capacity = 4)
:_a((int*)malloc(sizeof(int)*capacity)) //初始化列表
, _top(0)
, _capacity(capacity)
{
if (_a == nullptr)
{
perror("malloc fail");
exit(-1);
}
}但如果需要将初始化完成的动态内存空间进行初始化，那就需要混着来：
Stack(int capacity = 4)
: _top(0)
, _capacity(capacity)
{
_a = (int*)malloc(sizeof(int)capacity);
if (_a == nullptr)
{
perror("malloc fail");
exit(-1);
}
** memset(_a, 0, sizeof(int)capacity);
}
2.为什么要初始化列表
必须要有初始化列表的三种情况：
1.const修饰的成员变量；2.没有默认构造函数的自定义类型；3.引用类型
1.const修饰的成员变量
class A
{
public:
A()
{
_n = 1;
}
private:
const int _n; //声明
};
我们知道，const修饰的变量必须初始化，且只能在定义的时候初始化，且只能初始化一次，之后不能修改。
但在这里，对于const修饰的成员变量，没有显示初始化列表，而_n=1;这是在赋值，但n只能在定义的时候初始化，之后不能修改，所以我们必须用到初始化列表！
class A
{
public:
A()
:_n(1)
{}
private:
const int _n; //声明
};
2.没有默认构造函数的自定义类型
栈和队列：
class Stack
{
public:
//默认构造
Stack(int capacity = 4) //若Stack(int capacity),则没有默认构造
: _top(0)
, _capacity(capacity)
{
_a = (int*)malloc(sizeof(int)*capacity);
if (_a == nullptr)
{
perror("malloc fail");
exit(-1);
}
memset(_a, 0, sizeof(int)*capacity);
}
......
private:
int* _a; // 声明
int _top;
int _capacity;
};
class MyQueue {
public:
MyQueue()
{}
void push(int x)
{
_pushST.Push(x);
}
private:
Stack _pushST; //自定义类型
Stack _popST;
size_t _size = 0;
};
int main()
{
MyQueue q;
}
对于自定义类型 ：自定义类型若初始化列表中无显示的初始化，自定义类型就会调用默认构造函数，若没有默认构造函数，就需要在初始化列表中显示初始化，否则报错！
没有默认构造情况下: 若Stack(int capacity),则没有默认构造
class MyQueue {
public:
MyQueue()
: _pushST(5)
, _popST(5)
{}
......
private:
Stack _pushST; //自定义类型
Stack _popST;
size_t _size = 0;
};
3.引用类型
引用类型和const修饰的成员变量是一样的，都是能在定义的时候初始化。
class A
{
public:
A(int a)
:_a(a)
{}
private:
int _a=1;//缺省值
};
class B
{
public:
B(int a, int b)
:_b(a)
,_c(b)
,_n(10)
{}
private:
A _b; // 没有默认构造函数
int& _c; // 引用
const int _n; // const
};
成员变量在类中声明次序就是其在初始化列表中的初始化顺序，与其在初始化列表中的先后
次序无关：
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();
}
A. 输出1 1
B.程序崩溃
C.编译不通过
D.输出1 随机值
试一下，选什么？？
声明次序就是其在初始化列表中的初始化顺序
那么先初始化_a2,但因为 ,_a2(_a1)，_a1还没有初始化，所以_a1就是随机值。:_a1(a)到_a1初始化时，把a的值传过去，就是1。选D.
总结：
内置类型：在初始化列表中没有写显式初始化，就会用随机值初始化，若有缺省值，则就会用缺省值，若有显示初始化，则不会用缺省值。
自定义类型成员在初始化列表中，没有显式初始化，且没有默认构造函数，则需要在初始化列表中显示！
二、隐式类型转化
提到隐式类型转化，你有没有想起什么？？（没有就去点击链接回顾一下，引用那块）
int i = 0;
double d = i;(隐式类型转换），不同类型之间会产生一个临时变量
const double& rd = i; 给i起别名，但类型不同，产生临时变量，这时rd是临时变量的别名，临时变量具有常性，不加const会扩大权限。
1.单参数的构造函数支持隐式转换（C++98才支持）
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); //调用一次构造函数
// 隐式类型的转换
Date d2 = 2022; //调用一次构造函数，再调用一次拷贝构造
const Date& d5 = 2022; //临时变量具有常性，加const避免扩大权限
Date d3(d1);
Date d4 = d1;
}
把2022传参，调用构造函数创建临时变量，再把创建好的临时变量通过拷贝构造创建d2.
这样就会浪费资源，每创建一个对象，就调用两个函数，若是栈类，得浪费多大内存空间！！
优化：直接变成一个构造函数（后面会讲解）
2.多参数的构造函数的类型转化
class Date
{
public:
// 多参数构造
//Date(int year, int month=2, int day=2)
Date(int year, int month, int day)
: _year(year)
, _month(month)
, _day(day)
{}
private:
int _year;
int _month;
int _day;
};
int main()
{
Date d1(2022,10,20);//构造函数
Date d2={2022,10,20};//构造加拷贝
const Date& d3={2022,10,20};//const防止扩大临时变量权限（拷贝加构造）
}
他们的过程不一样，但结果是相同的。
3.*explicit***关键字 **
explicit修饰构造函数，禁止类型转换，explicit去掉之后，代码可以通过编译。
class Date
{
public:
// 多参数构造
explicit Date(int year, int month, int day)
, _month(month)
, _day(day)
{}
private:
int _year;
int _month;
int _day;
};
int main()
{
Date d1(2022, 10, 20);
Date d2 = {2022,10,20 };
return 0;
}
当然，单参数和多参数的构造函数隐式类型转化加explicit是一样的，加了之后，就不会支持隐式类型转化了。
三、static修饰的静态成员
1.static修饰公有成员变量
如果我想解决一个问题，就是统计一个类到底创建了多少个对象，应该怎么办呢？？
首先想到的是，全局变量？在每创建一个类，count++；但是全局变量不好的地方在于他是公开的，随便别人去修改，这会非常的不好，导致致命错误，不建议使用。
那么就想到了静态变量：静态局部变量，静态全局变量，类静态变量
静态局部变量在函数内定义，但不象自动变量那样，当调用时就存在，退出函数时就消失。静态局部变量始终存在着，也就是说它的生存期为整个源程序。
静态局部变量的生存期虽然为整个源程序，但是其作用域仍与自动变量相同，即只能在定义该变量的函数内使用该变量。退出该函数后，尽管该变量还继续存在，但不能使用它。
静态局部变量，静态全局变量，类静态变量：从始至终都存在，且只存在当前文件。且作用域不同。
类中的静态变量存储在 静态区，且作用域是类，属于每一个类的对象，我们访问它可以通过创建类，通过类去访问，也可以使用访问限定符A::N来访问。（前提是静态成员变量）
我们来计算创建了多少对象：
class A
{
public:
A(int a = 0)
:_a(a)
{
++N;
}
A(const A& aa)
:_a(aa._a)
{
++N;
}
static int N;
private:
int _a;
};
int A::N=0;//静态成员变量只能在类外定义初始化，在类内则会频繁初始化，一直改变值。
int main()
{
A aa1(1); //构造函数
A aa2 = 2; //构造加拷贝 优化为一个构造函数
A aa3 = aa1;//拷贝
cout<<A::N<<endl;
}
静态成员变量只能在类外定义初始化，在类内则会频繁初始化，一直改变值。
也验证了，编译器对于隐式类型转换的拷贝构造+默认构造会优化为一个拷贝构造。（如果没有优化就是四个），那我们再试传值返回，传引用返回，返回值，返回引用：
void f1(A aa)
{
}
A f2(A aa)
{
A b = aa;
return b;
}
int A::N = 0;
int main()
{
A aa1(1);
A aa2 = 2;
A aa3 = aa1;
f1(aa2);
f2(aa2);
cout << A::N << endl;
}
答案是：7，说明传值传参确实会调用一次拷贝构造，返回值也会创建临时变量去调用一次拷贝构造。
2.static修饰私有成员变量
为私有成员变量时：我们在类外使用，则需要通过类内的成员函数才可以访问到：
class A
{
public:
A(int a = 0)
:_a(a)
{
++N;
}
A(const A& aa)
:_a(aa._a)
{
++N;
}
int GetN()
{
return N;
}
private:
int _a;
static int N; // 声明
};
int main()
{
A aa();
cout<<aa.GetN()<<endl;
}
那么访问静态私有变量就需要创建一个对象，可不可以不创建就访问呢？
通过定义静态成员函数，就可以不定义对象直接调用，静态成员变量是没有this指针的，所以也不能调用其他成员变量。静态成员函数不需要this指针，是因为静态成员变量是类的所有对象共享的
只有那么一个，所以不管哪个对象调用返回的是同一个。所以静态不能访问非静态，所以静态成员函数是跟静态成员变量配合起来用的。
class A
{
public:
......
static int GetN()
{
return N;
}
private:
int _a;
static int N; // 声明
};
int main()
{
cout<<A::GetN()<<endl;
}
当然，私有变量只能获取，不能修改。
当限定了类创建的存储区域时：规定只能存储在栈区，那么创建在堆区等等的创建方式就不可以使用，但是只要创建类，就会调用类的构造函数，为了把对象创建在栈区，就需要把构造函数设置为私有，通过成员函数来访问。但是通过公有的成员函数访问私有构造函数，进而在成员函数中创建类，返回类。
class A
{
public:
static A GetObj(int a = 0)
{
A aa(a);
return aa;
}
private:
A(int a = 0)
:_a(a)
{}
private:
int _a;
};
int main()
{
//static A aa1; //静态区
//A* ptr = new A; //堆区
//A aa2; //栈区
//A aa3=Getobj(10); 错误
A aa3 = A::GetObj(10);
return 0;
}
但是最重要的一个问题是：你要调用函数，你就得创建对象，你要创建对象，你就得先调用函数，这不是？？？完了！！
那么这时，static作用就大了，因为设置为static静态成员函数，可以不用创建类就调用！
四、友元类和友元函数
在类和对象中，我们就已经接触过了，友元函数作用就是，偷家！！
class Date
{
friend inline ostream& operator<<(ostream& out, Date& d)
...
private:
int _year;
int _month;
int _day;
};
inline ostream& operator<<(ostream& out, Date& d)
{
out << d._year << " " << d._month << " " << d._day << endl;
return out;
}
当定义在类外的函数要使用私有变量时，就可以通过友元函数来访问。友元函数它就是一个普通函数，他没有this指针。
友元类也是偷家，只不过这次换成了类和类直接：
class A
{
friend Date B;//友元类
private:
int _a;
static int k;
public:
...
};
class B
{
private:
int _c;
int k;
public:
...
};
B是A的友元类，B能访问A的私有成员变量，但A不能访问B的私有成员变量。（假朋友）
五、内部类（C++中不重要）
就是类套类（类种类）
class A
{
private:
int _a;
static int k;
public:
// B天生就是A的友元
class B
{
int _b;
void foo(const A& a)
{
cout << k << endl;//OK,可以访问
cout << a._a << endl;//OK
}
};
};
1.计算类的内存大小时，sizeof(A)答案是四，因为A对象里没有B，只有自己的成员，这里就可以看作：他们两仅仅是嵌套定义，相当于两个独立的类。
但B类的访问受A类域访问限定符的限制！
A aa; //aa中没有B的对象
如果要创建一个B的对象，需要 A:: B bb;
只是域限定关系!
2.类种类，被套在里面的类天生是外面类的友元类，B可以访问A，但A不能访问B。
所以定义类时，如果有内部类，你就要小心了，小心不注意把你家偷光！
六、匿名对象
创建类有几种方式呢？
class A
{
public:
A(int a=0)
:N(a)
{}
int Sum_Solution()
{
return N;
}
private:
int N;
};
int main()
{
// 有名对象
A aa0;
A aa1(1);
A aa2 = 2; //单参数创建类隐式类型转化
//A aa3(); //不ok，会与函数声明冲突
// 匿名对象 --生命周期当前这一行
A();
A(3);
//A so;
//A.Sum_Solution(10);
A().Sum_Solution(10);
return 0;
}
匿名对象不需要对象名，且生命周期只是当前这一行。
当我们只是为了访问成员函数，而创建类去访问，那可不可以简单一些呢？
A so; A.Sum_Solution(10);
A().Sum_Solution(10); 这两个是一样的，这一行结束，匿名对象会自动调用析构函数。
七、编译器中的一些优化
编译器这些优化，只存在于 构造函数和拷贝构造函数之间，且适合一个表达式中的连续步骤，优化的前提当然不能改变原本的正确性！
下面来看几个例子，来了解如何优化，怎么优化：
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;
}
A f3()
{
/*A aa(10);
return aa;*/
return A(10);
}
int main()
{
// 优化场景1
A aa1 = 1; // A tmp(1) + A aa1(tmp) -> 优化 A aa1(1)
// 优化场景2
A aa1(1);
f1(aa1);
--------------
f1(A(1)); // 构造 + 拷贝构造 -> 优化 构造
f1(1); // 构造 + 拷贝构造 -> 优化 构造
//优化场景3
f2(); // 构造+拷贝构造
A ret = f2(); // 构造+拷贝构造+拷贝构造 ->优化 构造+拷贝构造，中间可能对aa还有一些操作，
// 不是连续的一个表达式 ，所以无法直接优化为一个构造
//优化场景4
A ret;
ret = f2();
----------------
A ret = f3(); // 构造+拷贝构造+拷贝构造 -> 优化 -> 构造
return 0;
}
场景1.
前面的单参数隐式类型创建类：
先拿1构造一个临时变量，再用临时变量拷贝aa1（构造+拷贝构造）
优化方式：直接为：A aa1(1)；就是构造函数
场景2.
A aa1(1); f1(aa1); 定义一个类，传参调用（构造+拷贝构造），无法优化，不保证是否需要对aa1对象进行操作，所以优化都是一个表达式中的连续步骤。
f1(A(1)); 直接利用匿名函数创建类，传值返回。（构造 + 拷贝构造 -> 优化 ：构造），因为匿名对象创建完自动析构，就相当于直接拿1去构造了f(1)中的形参 aa了
f1(1); 单参数隐式类型创建对象，1去构造临时变量，临时变量去拷贝形参。（ 构造 + 拷贝构造 -> 优化 ：构造）
场景3：
f(2)中，先构造一个类，再传值返回，就需要拷贝到临时变量。（构造+拷贝）
A ret = f2();先构造，再拷贝，再拷贝，因为要把返回值拷贝构造到ret对象。（构造+拷贝+拷贝），优化：在拷贝临时变量时，就直接将临时变量当作ret对象拷贝构造了。省略了第三步（构造+拷贝）。
场景4：
A ret; ret = f2();事先创建好了ret对象，ret = f2();不是拷贝构造，是赋值。（构造+拷贝）
A ret = f3();都在一个步骤里。 f3();中创建的是匿名对象，一个构造，后面还是一样，拷贝+拷贝。（构造+拷贝+拷贝）。优化：直接是一个构造函数。
f(3);中，直接创建一个匿名对象，不担心对他有其他操作，就是一个表达式中连续的步骤，直接优化，不会出现错误。
总结：
类和对象到现在就告一段落了，但是在日后的学习我们还是需要不断地回顾，毕竟知识是连续，联系性比较强的，大家继续加油！后面再见！
版权归原作者 The s.k.y. 所有， 如有侵权，请联系我们删除。