【C++】类和对象补充知识点

🏖️作者：@malloc不出对象
⛺专栏：C++的学习之路
👦个人简介：一名双非本科院校大二在读的科班编程菜鸟，努力编程只为赶上各位大佬的步伐🙈🙈

---

前言

本篇文章是对类和对象剩余知识点的补充，很多细节方面的东西我们需要把握住，大家一定要跟着我的步伐一步步来！！

一、再谈构造函数

1.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 初始化列表

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

下面我们来看看初始化列表的使用形式：

#include <iostream>
using namespace std;class A
{
public:A(): _a1(10), _a2(20){cout << _a1 << " " << _a2 << endl;}private:int _a1 = 1;int _a2 = 2;
};int main()
{A aa;return 0;
}

我们来看看结果：

从上述的结果我们可以发现在初始化列表中显式定义的成员变量会优先使用，如果初始化列表未显式定义的成员变量会使用缺省值，如果没有给缺省值的话就是随机值，因为构造函数对内置类型不做处理。

注：每个成员变量在初始化列表中只能出现一次(初始化只能初始化一次)。

下面我们接着来看看初始化列表与函数体的使用：

#include <iostream>
#include <stdlib.h>
using namespace std;class A
{
public:A(): _a1(10), _a2(20), _a((int*)malloc(100)){_a1++;_a2 = 10;_aa = (int*)malloc(20);}
private:int _a1 = 1;int _a2 = 2;int* _a;int* _aa;
};int main()
{A aa;return 0;
}

在初始化列表中我们先做"成员变量"的初始化，然后在函数体中做"成员变量"的赋值等各项操作。当然了初始化列表并不是所有事情都能做，所以我们可以在构造函数体内做。

---

Q：看完上述初始化列表的使用，那么初始化列表到底是在干什么？

简单来说， 初始化列表就是为每个"成员变量"定义!!!

那么为什么我们需要设计出初始化列表为每个"成员变量"定义呢？我们在构造函数中也能对成员变量进行赋值操作啊？

下面我们来看一个例子：

#include <iostream>
using namespace std;class A
{
public:A(){_a1 = 10;_a2 = 20;_x = 30;cout << _a1 << " " << _a2 << " " << _x << endl;}public:int _a1;int _a2;const int _x; 
};int main()
{A aa; return 0;
}

我们来看看结果：

从上图我们发现对于const修饰的成员变量在程序中是编译不通过的，我们来联系一下const的特性，const修饰变量是不是一定要进行初始化，那么在上述程序中我们没有对_x进行初始化操作，并且在构造函数中_x = 30也并不是初始化操作，而是赋值操作，对于const修饰的变量来说它是只读的，所以_x = 30显然也是不满足要求的，那么我们该如何解决？

我们想到使用缺省值对const修饰的_x进行声明，我们未显式初始化时使用的就是缺省值，这种方式是可行的！但这个特性是在C++11提出来为了解决默认构造函数不对内置类型做处理的，在C++11之前是如何解决的呢？

出于像const修饰成员变量这样必须在定义的位置进行初始化等问题，所以C++之父设计出了初始化列表给每个成员变量进行定义！！

---

Q：什么样的场景一定需要显式的将成员变量定义在初始化列表中呢？

1、引用成员变量
2、const成员变量
3、自定义类型成员(且该类没有默认构造函数时)

引用成员变量

class A
{
public:A():_a1(1){_a1++;}
private:int _a1;int _a2 = 10;int& _a3;
};int main()
{A aa;return 0;
}

我们必须要对成员变量_a3进行初始化引用：

_a1的别名为_a3，所以_a1发生什么变化_a3也随着会变化。

---

自定义类型成员找不到默认构造函数

class B
{
public:B(int b){cout << "B()" << endl;}
private:int _b;
};class A
{
public:A(): _a2(1), _ref(_a1), _x(1){_a1++;_a2--;}private:int _a1 = 1;int _a2 = 2;const int _x;int& _ref;B _bb;
};int main()
{A a;return 0;
}

对于_bb自定义类型成员来说，编译器会对它进行处理自动去调用它的默认构造函数，默认构造函数可以是无参构造函数、全缺省构造函数，但是在类B中找不到它的默认构造函数，类B中显式的定义了一个有参构造函数，那么我们就一定要传递实参才能调用类B中的有参构造函数。

---

对于初始化列表的再次理解：之前我们写的很多代码都没有显式使用初始化列表初始化，那么是否每个成员变量都被定义了呢？？

是的，即使我们没有显式的使用初始化列表初始化成员变量，但它一定是要通过初始化列表来定义的，例如：int a;这就叫做定义，它为变量a开辟了4个字节大小的空间，但是这块空间并没有显式的将某个值放到这块空间，所以是随机值，而对于int a = 10;来说这就叫做初始化，在开辟空间的同时显式的将10放到了这块空间。因此即使我们没有显式的在初始化列表中初始化成员变量，但每个成员变量也是被定义的了！！从另外一个角度来说，如果你没有定义成员变量那么你就没有空间，没有空间那么一切都是徒劳的实际没有起任何作用！！

总结：在以后我们尽量使用初始化列表初始化，因为不管你是否使用初始化列表，对于自定义类型成员变量，一定会先使用初始化列表初始化。如果成员变量没有在初始化列表显式初始化，对于内置类型，有缺省值就用缺省值，没有缺省值就是随机值；对于自定义类型，会去调用该自定义类型的默认构造函数，如果没有默认构造函数就会报错！！

---

下面我们继续来看看初始化列表的性质，大家来做做下面这道题：

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();return 0;
} A. 输出1 1
B.程序崩溃
C.编译不通过
D.输出1 随机值

相信接下来的答案会让部分读者大吃一斤：

我们发现_a2的值为随机值？？

这是成员变量在类中声明次序就是其在初始化列表中的初始化顺序，与其在初始化列表中的先后次序无关。_a2先进行声明，于是_a2先在初始化列表中进行初始化，此时变量_a1为随机值，那么变量_a2也就为随机值，，后对_a1变量进行显式初始化得到的就是1了。另外，我尝试了一下在声明位置为变量_a1提供了缺省值，但最终得出的答案是一样的，这里我个人猜想是因为变量_a1与_a2都是在初始化列表中显式初始化，因此根本用不上缺省值。

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

关于这个知识点大家也可以自行通过调试来观察初始化列表初始化的顺序。

二、explict关键字

构造函数不仅可以构造与初始化对象，对于单个参数或者除第一个参数无默认值其余均有默认值的构造函数，还具有类型转换的作用。

单参数构造函数隐式类型转换（C++98）

class A
{
public:A(int a): _a(a){cout << "A(int)" << endl;}A(const A& a){cout << "A(const A&)" << endl;}private:int _a;
};int main()
{A aa(1);	// 拷贝构造A aa2 = 1;  // 隐式类型转换，这里由构造 + 拷贝直接优化成了构造const A& ret = 10; // 产生一个临时变量，临时变量具有常属性，需要const修饰int i = 2; double d = i; // 隐式类型转换，int类型的变量i经过处理之后产生一个double类型临时变量，由临时变量返回给dcout << d << endl;return 0;
}

explicit 修饰构造函数禁止单参数隐式类型转换

如果我不想让自定义类型发生隐式类型转换，我们可以在构造函数前加上explicit关键字禁止隐式类型转换。

多参数构造函数隐式类型转换（C++11）

explicit 修饰构造函数禁止多参数隐式类型转换

关于这个关键字仅仅作为了解即可，因为构造函数隐式类型转换在实际用的还是比较多的，我们根据场合合理使用explicit关键字即可。

三、static成员

概念

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

注：静态成员变量一定要在类外进行初始化。

3.1 特性

1.静态成员为所有类对象所共享，不属于某个具体的对象，存放在静态区
2.静态成员变量必须在类外定义，定义时不添加 static 关键字，类中只是声明
3.类静态成员即可用 类名::静态成员 或者 对象.静态成员来访问
4.静态成员函数没有隐藏的 this 指针，不能访问任何非静态成员
5.静态成员也是类的成员，受public、protected、private 访问限定符的限制
6.static 成员变量在对象生成之前生成

我们来看一道题：请你实现一个类，计算程序中创建出了多少个类对象？

首先我们分析一个对象不是构造函数创建出来的就是拷贝构造函数创建出来的，所以我们只需要统计调用构造函数和拷贝构造函数的次数就可以了。

#include <iostream>
using namespace std;int count = 0;class A
{
public:A(int a = 0){++count;}A(const A& a){++count;}
};void Func(A a)
{}int main()
{A aa1;A aa2(aa1);Func(aa1);A aa3 = 1;cout << count << endl;return 0;
}

要解决这个命名冲突问题，一种方式是我们可以通过将这里的全局变量count重命名一下，另外一种方式是可以不将std命名空间域全局展开，将使用次数多的命名空间域的进行局部展开或者指定命名空间域即可，这也就是之前我们讲过的为什么不推荐using namespace全局展开命名空间域的原因。

通过全局变量计数的方式，就可以知道一个程序创建了多少个类对象，但是这种方式不是很好。因为全局变量是可以随时改变的，万一不小心改变了答案就出错了。C++ 是很注重数据的封装的，利用static成员变量就能很好的解决这个问题。

#include <iostream>
using namespace std;class A
{
public:A(int a = 0){++count;}A(const A& a){++count;}//private:static int count;  // 声明，这里不能给缺省值，因为缺省值是在构造函数初始化列表时使用的，但是我们的count是静态成员，它是共享的并不是某个特定对象的成员
};int A::count = 0; // 定义初始化void Func(A a)
{}int main()
{A aa1;A aa2(aa1);Func(aa1);A aa3 = 1;cout << A::count << endl;  // 通过类域找到静态成员cout << aa2.count << endl; // 通过对象访问静态成员cout << aa3.count << endl; // 同上A* ptr = nullptr;		   // 同样的这里的ptr并没有进行解引用，它是直接可以访问到count的cout << ptr->count << endl;return 0;
}

我们解决了全局变量被修改的问题，但static成员是公有的，并没有起到封装作用，我们该如何解决？

我们可以定义一个函数得到static成员的值，通过对象就可以调用函数得到静态成员的值了。

那么如果我们不想使用一个对象去调用函数而是直接调用这个函数呢？这时候我们就可以使用static成员函数了：

class A
{
public:A(int a = 0){++count;}A(const A& a){++count;}static int GetCount()   // 静态成员函数，它是没有this指针的因为它不属于某个特定的对象，它是共享的；{return count;		// 静态函数内只能只用静态成员，因为没有this指针所以不能去访问非静态成员，我们平时都是隐式的使用this指针来访问非静态成员的}private:static int count;  // 声明，这里不能给缺省值，因为缺省值是在构造函数初始化列表时使用的，但是我们的count是静态成员，它是共享的并不是某个特定对象的成员
};int A::count = 0; // 定义初始化void Func(A a)
{}int main()
{A aa1;A aa2(aa1);Func(aa1);A aa3 = 1;cout << A::GetCount() << endl;return 0;
}

静态成员函数的特性：

1.静态成员函数是被所有类对象共享的，放在静态区的。在类的外部使用范围解析运算符 :: 来重新声明静态变量从而对它进行初始化。
2.静态成员函数没有隐含this指针。
3.静态成员函数只能访问静态成员数据、其他静态成员函数和类外部的其他函数。
4.静态成员函数可以通过类名加范围解析运算符 :: 访问。
5.静态成员函数可以通过对象访问。

四、匿名对象

从字面意思上匿名对象就是没有名字的对象，你可以理解为是一个临时对象，一般是系统自动生成的。像我们以值的方式给函数传参、类型转换以及函数返回一个对象时都隐式的生成了一个匿名对象。

下面我们来看看匿名对象的简单用法：

#include <iostream>
using namespace std;class A
{
public:A(int a = 10):_a(a){cout << this << ": A(int a)" << endl;}~A(){cout << this << ": ~A()" << endl;}void Print(){cout << this << ": " << _a << endl;}private:int _a;
};A Func()
{return A(20);
}int main()
{A aa = A(1);  // 匿名对象赋值实例化对象A().Print();  // 匿名对象调用成员函数A(30);		  // 匿名对象调用构造函数Func();		  // 匿名对象做返回值return 0;
}

4.1 匿名对象的生命周期

关于匿名对象的用法是比较简单的，最重要的是它的生命周期！！下面我们就来探究一下匿名对象的生命周期！！我们以上述代码的结果来进行分析：

从上图我们发现匿名对象在外面没有对象等待被其实例化时调用完构造函数之后马上就会调用析构函数，这是巧合吗？并不是，我们看向第一个实例化对象，它是最后才被析构的，而不是调用完构造之后立马析构。
除第一条代码之外，其余生成的匿名对象在外面没有对象等待被其实例化，此匿名对象的生命周期只有这一行，将会在构造函数生成之后立马被析构，而第一行代码正是由于生成的匿名对象在外部有对象等待被它实例化，此匿名对象的生命周期就变成了外部对象的生命周期，也就是在出了main函数之后才会被析构！！

总结：如果生成的匿名对象在外面没有对象等待被其实例化，此匿名对象的生命周期就只有这一行，将会在调用构造函数之后立马析构；如果生成的匿名对象在外部有对象等待被它实例化，此匿名对象的生命周期就变成了外部对象的生命周期。

五、内部类

概念：如果一个类定义在另一个类的内部，这个内部类就叫做内部类。内部类是一个独立的类，它不属于外部类，更不能通过外部类的对象去访问内部类的成员。外部类对内部类没有任何优越的访问权限。

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

特性：

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

sizeof(外部类) = 外部类

#include <iostream>
using namespace std;class A
{
public:class B	// 内部类B天生就是外部类A的友元{int _b;};
private:int _a;
};int main()
{cout << sizeof(A) << endl;cout << sizeof(A::B) << endl;return 0;
}

从结果上我们看到外部类A与内部类B的大小是一样的，外部类A的大小为4，这说明外部类A根本没有包括内部类成员！！它们两者是独立不同的两块空间。

注意：外部类与内部类相当于两个不同的空间，只是内部类的访问受外部类作用域和访问限定符的限制。

我们接着来继续看看内部类的特性：

#include <iostream>
using namespace std;class A
{
private:static int k;int h = 1;
public:class B // B天生就是A的友元，所以类B能够访问类A的成员变量{public:void foo(const A& a){cout << k << endl;		//OKcout << a.h << endl;	//OK}void Print(){cout << "hello world" << endl;}private:int _b;};
};int A::k = 10;  // 静态成员初始化int main()
{A::B b;b.foo(A());return 0;
}

上述代码中类B是A的内部类，天生是类A的友元(朋友)，所以类B能够访问类A的成员，但类A不能访问类B的成员。这里有一个形象的比喻，你把你喜欢的人当朋友，但是她拿你做备胎当ATM，所以对于感情我们一定要学会理智，不要当舔狗，最后舔到一无所有🙈🙈

六、拷贝对象时编译器做的一些优化处理

在传参和传返回值的过程中，一般比较新的编译器会做一些优化，减少对象的拷贝，这个在一些场景下还是非常有用的。

优化场景1：函数传参

class A
{
public:A(int a = 10): _a(a){cout << this << ": A(int)" << endl;}A(const A& a){cout << this << ": A(const A&)" << endl;}~A(){cout << this << ": ~A()" << endl;}private:int _a;
};// 传值传参
void Func1(A aa)
{}// 传引用传参
void Func2(const A& aa)
{}int main()
{A aa1 = 1;   // 连续进行构造 + 拷贝构造  ==> 构造// 传值传参Func1(aa1);  // 拷贝构造  未优化Func1(2);    // 连续进行构造 + 拷贝构造 ==> 构造Func1(A(3)); // 构造 + 拷贝构造 ==> 构造cout << "----------------------------------------" << endl;// 传引用传参Func2(aa1); // 未进行任何对象的创建Func2(2);   // 构造，无拷贝构造  未优化Func2(A(3));// 构造，无拷贝构造  未优化return 0;		
}

优化场景2：对象返回

有些读者可能不清楚其中的构造、拷贝构造以及析构函数等的调用顺序，这里我们每调用一次函数就打印当前对象的地址，这样大家就能更加清楚整个过程。

#include <iostream>
using namespace std;class A
{
public:A(int a = 10): _a(a){cout << this << ": A(int)" << endl;}A(const A& a){cout << this << ": A(const A&)" << endl;}~A(){cout << this << ": ~A()" << endl;}A& operator=(const A& d){cout << this << ": operator=(const A&)" << endl;return *this;}private:int _a;
};A Func3()
{A aa;return aa;
}A Func4()
{return A();
}int main()
{Func3();	// 构造 + 拷贝构造// 拷贝构造方式接收返回对象A aa2 = Func3(); // 构造 + 拷贝构造 + 拷贝构造 ==> 构造 + 拷贝构造cout << "----------------------------------------" << endl;// 赋值接收返回对象A aa3;			// 构造aa3 = Func3();  // 构造 + 拷贝构造 + 赋值拷贝  未优化cout << "----------------------------------------" << endl;// 返回匿名对象Func4();		 // 构造 + 拷贝构造 ==> 构造A aa4 = Func4(); // 构造 + 拷贝构造 ==> 构造 + 构造拷贝  ==> 构造return 0;
}

总结：

对象返回：
1.接收返回值对象，尽量拷贝构造函数接收，不要赋值接收
2.函数返回对象时，尽量返回匿名对象

函数传参：
1.尽量使用const& 传参

七、再次理解类和对象

在类和对象阶段，大家一定要体会到，类是对某一类实体(对象)来进行描述的，描述该对象具有那些属性，那些方法，描述完成后就形成了一种新的自定义类型，才用该自定义类型就可以实例化具体的对象。