CC++面试重点大集合

Posted 2021-06-25 CodeBowl

春招的时候，我自己整理了一份C++的面试重点，面试了七八家，发现基本没有超出这个范围的，可以说，背下本文的重点，对于想找一份C++开发工作的小伙伴来说，已经成功了一半。

本文除了帮助作者找到了大厂工作，还帮助我周围很多小伙伴拿下了心仪的offer，可以说目标不是大厂的小伙伴，只要把这些掌握了，拿一个二三线城市10k+，一线城市15k+的工作是没问题的。

本文篇幅较长，内容较长但都是精华，建议有需要的小伙伴收藏熟记！

本文针对于需求C++开发工作的小伙伴，整理了C++相关重点，本系列将持续更新，喜欢的小伙伴希望来个一键三连。

目录

• • 你怎么理解C语言和C++的区别？⭐⭐⭐⭐⭐
  • 一句话说明什么是面向对象思想⭐⭐⭐⭐⭐
  • 简述下C++语言的特点⭐⭐⭐⭐
  • C++的函数调用约定方式⭐⭐⭐⭐
  • C++文件编译与执行的四个阶段⭐⭐⭐⭐
  • 动态链接与静态链接？两者有什么区别⭐⭐⭐⭐
  • 深拷贝和浅拷贝⭐⭐⭐⭐
  • 指针和引用 ⭐⭐⭐⭐⭐
  • Extern “C” ⭐⭐⭐
  • C++的内存分区 ⭐⭐⭐⭐
  • 堆和栈的区别⭐⭐⭐⭐
  • 栈溢出的原因及解决办法⭐⭐⭐
  • new和malloc有什么异同⭐⭐⭐⭐⭐
  • 内存泄漏怎么产生的？如何避免？⭐⭐⭐⭐⭐
  • 关键字static的作用⭐⭐⭐⭐⭐
  • 为什么静态成员函数不能访问非静态成员⭐⭐⭐⭐⭐
  • 静态成员函数与普通成员函数的区别⭐⭐⭐⭐⭐
  • 静态局部变量，全局变量，局部变量的特点，以及使用场景⭐⭐⭐⭐
  • const和define的区别⭐⭐⭐⭐⭐
  • const的作用⭐⭐⭐⭐⭐
  • 什么是宏？⭐⭐⭐⭐
  • 为什么要少使用宏？C++有什么解决方案？⭐⭐⭐⭐⭐
  • 结构体struct和共同体union（联合）的区别⭐⭐⭐
  • c++中类和c语言中struct的区别(至少两点)⭐⭐⭐
  • 重载overload，覆盖override，重写overwrite，这三者之间的区别⭐⭐⭐
  • C++是不是类型安全的？⭐⭐⭐
  • C++为什么用模板类，为什么用泛型⭐⭐⭐
  • 什么是野指针⭐⭐⭐⭐
  • 智能指针⭐⭐⭐⭐⭐
  • 说几个C++11的新特性⭐⭐⭐
• 结语

你怎么理解C语言和C++的区别？⭐⭐⭐⭐⭐

1.C语言是C++的子集，C++可以很好兼容C语言。但是C++又有很多新特性，如引用、智能指针、auto变量等。
2.C++是面向对象的编程语言，C++引入了新的数据类型——类，由此引申出了三大特性（1）封装（2）继承（3）多态。而C语言则是面向过程的编程语言。
3.C语言有一些不安全的语言特性，如指针使用的潜在危险、强制转换的不确定性、内存泄露等。而C++对此增加了不少新特性来改善安全性，如const常量、引用、cast转换、智能指针、try—catch等等；
4.C++可复用性高，C++引入了模板的概念，后面在此基础上，实现了方便开发的标准模板库STL（Standard Template Library）。STL的一个重要特点是数据结构和算法的分离，其体现了泛型化程序设计的思想。C++的STL库相对于C语言的函数库更灵活、更通用。

一句话说明什么是面向对象思想⭐⭐⭐⭐⭐

把一组数据结构和处理它们的方法组成对象（object），把相同行为的对象抽象归纳为类（class），通过类的封装（encapsulation）隐藏内部细节，通过继承（inheritance）实现类的泛化（generalization），通过多态（polymorphism）实现基于对象类型的动态分派（dynamic dispatch）.

简述下C++语言的特点⭐⭐⭐⭐

1、在C语言的基础上进行扩充和完善，使C++兼容了C语言的面向过程特点，又成为了一种面向对象的程序设计语言；
2、可以使用抽象数据类型进行基于对象的编程；
3、可以使用多继承、多态进行面向对象的编程；
4、可以担负起以模版为特征的泛型化编程。
C++与C语言的本质差别：在于C++是面向对象的，而C语言是面向过程的。或者说C++是在C语言的基础上增加了面向对象程序设。

C++的函数调用约定方式⭐⭐⭐⭐

1、__cdecl

__cdecl调用约定又称为 C 调用约定，是 C/C++ 语言缺省的调用约定。参数按照从右至左的方式入栈，函数本身不清理栈，此工作由调用者负责，返回值在EAX中。由于由调用者清理栈，所以允许可变参数函数存在，如int sprintf(char* buffer,const char* format,…);。

2、__stdcall
__stdcall 很多时候被称为 pascal 调用约定。pascal 语言是早期很常见的一种教学用计算机程序设计语言，其语法严谨。参数按照从右至左的方式入栈，函数自身清理堆栈，返回值在EAX中。

3、__fastcall
顾名思义，__fastcall 的特点就是快，因为它通过 CPU 寄存器来传递参数。他用 ECX 和 EDX 传送前两个双字（DWORD）或更小的参数，剩下的参数按照从右至左的方式入栈，函数自身清理堆栈，返回值在 EAX 中。

4、__thiscall
这是 C++ 语言特有的一种调用方式，用于类成员函数的调用约定。如果参数确定，this 指针存放于 ECX 寄存器，函数自身清理堆栈；如果参数不确定，this指针在所有参数入栈后再入栈，调用者清理栈。__thiscall 不是关键字，程序员不能使用。参数按照从右至左的方式入栈。

C++文件编译与执行的四个阶段⭐⭐⭐⭐

1）预处理：根据文件中的预处理指令来修改源文件的内容

2）编译：编译成汇编代码

3）汇编：把汇编代码翻译成目标机器指令

4）链接：链接目标代码生成可执行程序

动态链接与静态链接？两者有什么区别⭐⭐⭐⭐

链接分为静态链接和动态链接。

1.静态链接，是在链接的时候就已经把要调用的函数或者过程链接到了生成的可执行文件中，就算你在去把静态库删除也不会影响可执行程序的执行；生成的静态链接库，Windows下以.lib为后缀，Linux下以.a为后缀。

2.而动态链接，是在链接的时候没有把调用的函数代码链接进去，而是在执行的过程中，再去找要链接的函数，生成的可执行文件中没有函数代码，只包含函数的重定位信息，所以当你删除动态库时，可执行程序就不能运行。生成的动态链接库，Windows下以.dll为后缀，Linux下以.so为后缀。

区别

1.静态链接是将各个模块的obj和库链接成一个完整的可执行程序；而动态链接是程序在运行的时候寻找动态库的函数符号（重定位）

2.静态链接运行快、可独立运行；动态链接运行较慢(事实上，动态库被广泛使用，这个缺点可以忽略)、不可独立运行。

3.静态链接浪费空间，存在多个副本，同一个函数的多次调用会被多次链接进可执行程序，当库和模块修改时，main也需要重编译；动态链接节省空间，相同的函数只有一份，当库和模块修改时，main不需要重编译。

深拷贝和浅拷贝⭐⭐⭐⭐

浅复制：仅仅是指向被复制的内存地址，如果原地址发生改变，那么浅复制出来的对象也会相应的改变。
深复制：在计算机中开辟一块新的内存地址用于存放复制的对象。

深拷贝和浅拷贝最根本的区别在于是否真正获取一个对象的复制实体，而不是引用。
假设B复制了A，修改A的时候，看B是否发生变化：
如果B跟着也变了，说明是浅拷贝，拿人手短！（修改堆内存中的同一个值）
如果B没有改变，说明是深拷贝，自食其力！（修改堆内存中的不同的值）

指针和引用 ⭐⭐⭐⭐⭐

本质：
引用是别名，指针是地址

1.指针在运行时可以改变其所指向的值，而引用一旦和某个对象绑定后就不再改变。
这句话可以理解为：指针可以被重新赋值以指向另一个不同的对象。但是引用则总是指向在初始化时被指定的对象，以后不能改变，但是指定的对象其内容可以改变。

2.从内存分配上看，程序为指针变量分配内存区域，而不为引用分配内存区域，
因为引用声明时必须初始化，从而指向一个已经存在的对象。引用不能指向空值。

3.从编译上看，程序在编译时分别将指针和引用添加到符号表上，符号表上记录的是变量名及变量所对应地址。指针变量在符号表上对应的地址值为指针变量的地址值，而引用在符号表上对应的地址值为引用对象的地址值。
符号表生成后就不会再改，因此指针可以改变指向的对象（指针变量中的值可以改），而引用对象不能改。这是使用指针不安全而使用引用安全的主要原因。从某种意义上来说引用可以被认为是不能改变的指针。

4.不存在指向空值的引用这个事实，意味着使用引用的代码效率比使用指针的要高。
因为在使用引用之前不需要测试它的合法性。相反，指针则应该总是被测试，防止其为空。

5.就++操作而言，对引用的操作直接反应到所指向的对象，而不是改变指向；而对指针的操作，会使指针指向下一个对象，而不是改变所指对象的内容。

Extern “C” ⭐⭐⭐

Extern “C”是由Ｃ＋＋提供的一个连接交换指定符号，用于告诉Ｃ＋＋这段代码是Ｃ函数。
这是因为C++编译后库中函数名会变得很长，与C生成的不一致，造成Ｃ＋＋不能直接调用C函数，加上extren “c”后，C++就能直接调用C函数了。

C++的内存分区 ⭐⭐⭐⭐

C++的内存分区共有五个部分：
栈区（stack）：主要存放函数参数以及局部变量，由系统自动分配释放。
堆区（heap）：由用户通过 malloc/new 手动申请，手动释放。
全局/静态区：存放全局变量、静态变量；程序结束后由系统释放。
字符串常量区：字符串常量就放在这里，程序结束后由系统释放。
代码区：存放程序的二进制代码。

堆和栈的区别⭐⭐⭐⭐

1.栈由编译器自动分配释放，存放函数参数、局部变量等。而堆由程序员手动分配和释放；
2.栈是向低地址扩展的数据结构，是一块连续的内存的区域。而堆是向高地址扩展的数据结构，会因为内存碎片成为不连续的内存区域；
3.栈的默认大小为1M左右(x86程序，保留1MB，初始提交4KB)，而堆的大小可以达到几G，仅受限于计算机系统中有效的虚拟内存。

栈溢出的原因及解决办法⭐⭐⭐

栈的大小一般默认为1M左右，导致栈溢出的常见原因有两个：
· 函数调用层次过深，每调用一次就压一次栈。
· 局部变量占用空间太大。

解决办法：
· 增加栈内存（例如命令：ulimit -s 32768）
· 使用堆，比如动态申请内存、static修饰。

new和malloc有什么异同⭐⭐⭐⭐⭐

1. new/delete是C++关键字，需要编译器支持。malloc/free是库函数，需要头文件支持。

2. 使用new操作符申请内存分配时无须指定内存块的大小，编译器会根据类型信息自行计算。而malloc则需要显式地指出所需内存的尺寸。

3. new操作符内存分配成功时，返回的是对象类型的指针，类型严格与对象匹配，无须进行类型转换，故new是符合类型安全性的操作符。而malloc内存分配成功则是返回void * ，需要通过强制类型转换将void*指针转换成我们需要的类型。

4. new内存分配失败时，会抛出bac_alloc异常。malloc分配内存失败时返回NULL。

5. new会先调用operator new函数，申请足够的内存（通常底层使用malloc实现）。然后调用类型的构造函数，初始化成员变量，最后返回自定义类型指针。delete先调用析构函数，然后调用operator delete函数释放内存（通常底层使用free实现）。 malloc/free是库函数，只能动态的申请和释放内存，无法强制要求其做自定义类型对象构造和析构工作。

6. C++允许重载new/delete操作符，特别的，布局new的就不需要为对象分配内存，而是指定了一个地址作为内存起始区域，new在这段内存上为对象调用构造函数完成初始化工作，并返回此地址。而malloc不允许重载。

7. 内存区域 new操作符从自由存储区（free store）上为对象动态分配内存空间，而malloc函数从堆上动态分配内存。自由存储区是C++基于new操作符的一个抽象概念，凡是通过new操作符进行内存申请，该内存即为自由存储区。而堆是操作系统中的术语，是操作系统所维护的一块特殊内存，用于程序的内存动态分配，C语言使用malloc从堆上分配内存，使用free释放已分配的对应内存。自由存储区不等于堆，如上所述，布局new就可以不位于堆中。

8. 最大的不同在于，new不仅分配一段内存，而且会调用构造函数，但是malloc则不会

9. 两者的资源都需要手动释放

内存泄漏怎么产生的？如何避免？⭐⭐⭐⭐⭐

我们所说的内存泄漏一般是指堆内存的泄漏，也就是程序在运行过程中动态申请的内存空间不再使用后没有及时释放，导致那块内存不能被再次使用。
更广义的内存泄漏还包括未对系统资源的及时释放，比如句柄、socket等没有使用相应的函数释放掉，导致系统资源的浪费。

解决方法：
养成良好的编码习惯和规范，记得及时释放掉内存或系统资源。
重载new和delete，以链表的形式自动管理分配的内存。
使用智能指针（share_ptr,unique_ptr,weak_ptr用法）。

关键字static的作用⭐⭐⭐⭐⭐

1）函数体内： static 修饰的局部变量作用范围为该函数体，不同于auto变量，其内存只被分配一次，因此其值在下次调用的时候维持了上次的值

2）模块内：static修饰全局变量或全局函数，可以被模块内的所有函数访问，但是不能被模块外的其他函数访问，使用范围限制在声明它的模块内

3）类中：修饰成员变量，表示该变量属于整个类所有，对类的所有对象只有一份拷贝

4）类中：修饰成员函数，表示该函数属于整个类所有，不接受this指针，只能访问类中的static成员变量

注意和const的区别！！！const强调值不能被修改，而static强调唯一的拷贝，对所有类的对象

为什么静态成员函数不能访问非静态成员⭐⭐⭐⭐⭐

静态成员函数不属于任何一个对象，因此C++规定静态成员函数没有this指针。既然它没有指向某一对象，也就无法对一个对象中的非静态成员进行访问。

静态成员函数与普通成员函数的区别⭐⭐⭐⭐⭐

静态成员函数没有 this 指针，只能访问静态成员（包括静态成员变量和静态成员函数）。
普通成员函数有 this 指针，可以访问类中的任意成员；而静态成员函数没有 this 指针。

静态局部变量，全局变量，局部变量的特点，以及使用场景⭐⭐⭐⭐

1.首先从作用域考虑：C++里作用域可分为6种：全局，局部，类，语句，命名空间和文件作用域。

全局变量：全局作用域，可以通过extern作用于其他非定义的源文件。

静态全局变量 ：全局作用域+文件作用域，所以无法在其他文件中使用。

局部变量：局部作用域，比如函数的参数，函数内的局部变量等等。

静态局部变量 ：局部作用域，只被初始化一次，直到程序结束。

2.从所在空间考虑：除了局部变量在栈上外，其他都在静态存储区。因为静态变量都在静态存储区，所以下次调用函数的时候还是能取到原来的值。

3.生命周期：局部变量在栈上，出了作用域就回收内存；而全局变量、静态全局变量、静态局部变量都在静态存储区，直到程序结束才会回收内存。

4.使用场景：从它们各自特点就可以看出各自的应用场景，不再赘述。

const和define的区别⭐⭐⭐⭐⭐

const用于定义常量；而define用于定义宏，而宏也可以用于定义常量。都用于常量定义时，它们的区别有：

1.const生效于编译的阶段；define生效于预处理阶段。
2.const定义的常量，在C语言中是存储在内存中、需要额外的内存空间的；define定义的常量，运行时是直接的操作数，并不会存放在内存中。
3.const定义的常量是带类型的；define定义的常量不带类型。因此define定义的常量不利于类型检查。

const的作用⭐⭐⭐⭐⭐

1、修饰常量时：

const int temp1; //temp1为常量，不可变
int const temp2; //temp2为常量，不可变

2、修饰指针时：
　　主要看const在*的前后，在前则指针指向的内容为常量，在后则指针本身为常量；

	const int *ptr;  //*ptr为常量；
　　int const *ptr;  //*ptr为常量；
　　int* const ptr;  //ptr为常量；
　　const int * const ptr;  //*ptr、ptr均为常量；

3、const修饰类对象时：

const修饰类对象时，其对象中的任何成员都不能被修改。const修饰的对象，该对象的任何非const成员函数都不能调用该对象，因为任何非const成员函数都会有修改成员变量的可能。

class TEMP{
　　　　void func1();
　　　　void func2() const;
　　}
　　const TEMP temp;
　　temp.func1(); //错误；
　　temp.func2(); //正确；

4、const修饰成员变量：

const修饰的成员变量不能被修改，同时只能在初始化列表中被初始化，因为常量只能被初始化，不能被赋值；

赋值是使用新值覆盖旧值构造函数是先为其开辟空间然后为其赋值，不是初始化；而初始化列表开辟空间和初始化是同时完成的，直接给与一个值，所以const成员变量一定要在初始化列表中完成。

class TEMP{
　　　　const int val;      
　　　　TEMP(int x)val(x){};  //只能在初始化列表中赋值；
　　}

5、const修饰类的成员函数

const成员函数表示该成员函数不能修改类对象中的任何非const成员变量。一般const写在函数的后面，形如：void func() const;

如果某个成员函数不会修改成员变量，那么最好将其声明为const，因为const成员函数不会对数据进行修改，如果修改，编译器将会报错；

class TEMP{
　　　　void func()const; //常成员函数，不能修改对象中的成员变量，也不能调用类中任何非const成员函数；
　　}

6、const在函数声明中的使用：
在函数声明中，const可以修饰函数的返回值，也可以修饰具体某一个形参；

修饰形参时，用相应的变量初始化const常量，在函数体内，按照const所修饰的部分进行常量化；

修饰函数返回值时，一般情况下，const修饰返回值多用于操作符的重载。通常不建议用const修饰函数的返回值类型为某个对象或某个对象引用的情况；

//修饰返回值
const int func(void);
//修饰参数，说明不希望参数在函数体内被修改
int func(const int i);
//修饰成员函数，其目的是防止成员函数修改被调用对象的值
int func(void) const;

什么是宏？⭐⭐⭐⭐

#define命令是一个宏命令，它用来将一个标识符定义为一个字符串，该标识符被称为宏名，被定义的字符串称为替换文本。

该命令有两种格式：一种是不带参数的宏定义，另一种是带参数的宏定义。

为什么要少使用宏？C++有什么解决方案？⭐⭐⭐⭐⭐

1.由程序编译的四个过程，知道宏是在预编译阶段被展开的。在预编译阶段是不会进行语法检查、语义分析的，宏被暴力替换，正是因为如此，如果不注意细节，宏的使用很容易出现问题。比如在表达式中忘记加括号等问题。

2.正因为如此，在C++中为了安全性，我们就要少用宏。

不带参数的宏命令我们可以用常量const来替代，比如const int PI = 3.1415，可以起到同样的效果，而且还比宏安全，因为这条语句会在编译阶段进行语法检查。

而带参数的宏命令有点类似函数的功能，在C++中可以使用内联函数或模板来替代，内联函数与宏命令功能相似，是在调用函数的地方，用函数体直接替换。但是内联函数比宏命令安全，因为内联函数的替换发生在编译阶段，同样会进行语法检查、语义分析等，而宏命令发生在预编译阶段，属于暴力替换，并不安全。

结构体struct和共同体union（联合）的区别⭐⭐⭐

结构体：将不同类型的数据组合成一个整体，是自定义类型

共同体：不同类型的几个变量共同占用一段内存

1）结构体中的每个成员都有自己独立的地址，它们是同时存在的；共同体中的所有成员占用同一段内存，它们不能同时存在；
2）sizeof(struct)是内存对齐后所有成员长度的总和，sizeof(union)是内存对齐后最长数据成员的长度

c++中类和c语言中struct的区别(至少两点)⭐⭐⭐

(1) c++中的类默认的成员是私有的，struct默认的是共有的。

(2) c++中的类可以定义成员函数，struct只能定义成员变量。

重载overload，覆盖override，重写overwrite，这三者之间的区别⭐⭐⭐

1.overload，将语义相近的几个函数用同一个名字表示，但是参数和返回值不同，这就是函数重载
特征：相同范围（同一个类中）、函数名字相同、参数不同、virtual关键字可有可无
2.override，派生类覆盖基类的虚函数，实现接口的重用
特征：不同范围（基类和派生类）、函数名字相同、参数相同、基类中必须有virtual关键字（必须是虚函数）
3.overwrite，派生类屏蔽了其同名的基类函数.

C++是不是类型安全的？⭐⭐⭐

不是。两个不同类型的指针之间可以强制转换（用reinterpret cast)。C#是类型安全的。

C++为什么用模板类，为什么用泛型⭐⭐⭐

通过泛型可以定义类型安全的数据结构（类型安全），而无须使用实际的数据类型（可扩展）。这能够显著提高性能并得到更高质量的代码（高性能），因为您可以重用数据处理算法，而无须复制类型特定的代码（可重用）。

什么是野指针⭐⭐⭐⭐

野指针不是NULL指针，是未初始化或者未清零的指针，它指向的内存地址不是程序员所期望的，可能指向了受限的内存

成因：

1）指针变量没有被初始化

2）指针指向的内存被释放了，但是指针没有置NULL

3）指针超过了变量了的作用范围，比如b[10]，指针b+11

智能指针⭐⭐⭐⭐⭐

1.auto_ptr的作用：
作用1：保证一个对象在某个时间只能被一个该种类型的智能指针所指向，就是通常所说的对象所有权。
作用2：对指向的对象自动释放的作用。

2.shared_ptr采用引用计数的方式管理所指向的对象。当有一个新的shared_ptr指向同一个对象时（复制shared_ptr等），引用计数加1。当shared_ptr离开作用域时，引用计数减1。当引用计数为0时，释放所管理的内存。(一般使用make_shared来获得shared_ptr。)
3. unique_ptr对于所指向的对象是独占的。所以，不可以对unique_ptr进行拷贝、赋值等操作，但是可以通过release函数在unique_ptr之间转移控制权。
4. weak_ptr一般和shared_ptr配合使用。它可以指向shared_ptr所指向的对象，但是却不增加对象的引用计数。这样就有可能出现weak_ptr所指向的对象实际上已经被释放了的情况。因此，weak_ptr有一个lock函数，尝试取回一个指向对象的shared_ptr。

说几个C++11的新特性⭐⭐⭐

auto类型推导
范围for循环
lambda函数
override 和 final 关键字
空指针常量nullptr
线程支持、智能指针等

结语

本文整理了C++面试的相关语言基础，但是对于类和多态等内容在本文中没有整理，因为它们十分的重要，且需要的篇幅也较多，所以我会在下篇文章中单独整理。