【c++】经典面试题吐血整理_c c++面试题大全 96页

既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，涵盖了95%以上物联网嵌入式知识点，真正体系化！

由于文件比较多，这里只是将部分目录截图出来，全套包含大厂面经、学习笔记、源码讲义、实战项目、大纲路线、电子书籍、讲解视频，并且后续会持续更新

需要这些体系化资料的朋友，可以加我V获取：vip1024c （备注嵌入式）

如果你需要这些资料，可以戳这里获取

	- unique\_ptr:唯一拥有所指对象
	- weak\_ptr:是为了配合shared\_ptr而引入的智能指针，为了避免shared\_ptr相互指向产生环形结构。
+ 头文件：memery
+ 引用智能指针的目的
	- 程序员不用手动释放资源，方便内存管理
	- 利用了RAII（资源获取既初始化）的技术对普通指针进行封装，这使智能指针表现为一个指针但是实质却是一个对象。
1
2
3
4
5
6

• null_ptr和null

  • 在c++中null被定义为0，这样就会带来一些问题，比如说，一个函数的形式参数是一个指针，当传入的指针为空的时候，如果用null，那么就会传入一个0，这个时候就会有错误。null_ptr就是为了解决这样一个问题而出现的。
  • null是宏定义，但是null_ptr是关键字，用来声明一个空指针

• 野指针

  • 定义：指向不可用内存的指针
  • 造成野指针的三个原因
    • 1.指针变量没有被初始化
    • 2.指针所指向的内存被释放了，但是指针本身却没有被置为null
    • 3.指针超过了变量的作用范围（局部变量）
  • 指针悬挂：指向一个已经释放的内存空间

• 纯虚函数和抽象类

  • https://blog.csdn.net/qq_39328436/article/details/113406016

    • 定义:
      • 纯虚函数：纯虚函数是一种特殊的虚函数，他在基类中声明但是不在基类中定义具体的操作
      • 抽象类：含有纯虚函数的类叫做抽象类，若派生类没有重写这一个纯虚函数，那么派生类也是抽象类
    • 注意：
      • 不能创建抽象类的对象，不能用new,但是可以声明对象指针
    • 例子：“形状”是一个抽象类，“求面积”就是一个纯虚函数，只有“形状”的派生类，比如正方形，才能被实例化并且重写这个纯虚函数。

• 指针和引用的区别

  • 本质：引用是别名，指针是地址
  • 安全性：引用安全，指针不安全，用不好会造成内存泄露
  • 可空，可变：
    • 指针可以为空，指向的对象可以改变
    • 引用在初始化时确定了对象之后就不能再改变
  • 空间大小：引用的大小就是它对象的大小，指针的本质是一个地址，所以在同一台计算机中，指针所占的存储容量是确定的，比如说32位的计算机，那就是4字节。64位的计算机中就是8字节
  • 另外：二级指针就是指针的指针，他存放的是指针变量的地址

• 右值引用

  • 左值和右值
    • 右值：没有名字，不能被修改的变量和表达式(a+b=3)a+b是右值
    • 左值：既可以出现在等号左边又可以出现在等号右边的量
    • 左值也可以是右值，右值不能是左值
  • 左值引用和右值引用
    • 左值引用， 使用 T&, 只能绑定左值
    • 右值引用， 使用 T&&， 只能绑定右值
    • 常量左值， 使用 const T&, 既可以绑定左值又可以绑定右值
    • 已命名的右值引用，编译器会认为是个左值
  • 右值引用的好处
    • 避免无意义的复制
    • 避免无意义的析构
    • 延长右值的声明周期
  • 类的构造函数的形式参数使用右值引用（移动构造函数）的好处
    • 场景：当一个类中含有指针类型的成员变量，并在构造函数中对这个指针成员变量进行初始化。这个时候实例化多个对象，多个对象中的这个指针成员都会指向同一块，删除对象时，会导致指针重复删除，造成指针悬空现象。
    • 解决办法：
      • 深拷贝构造函数
      • 移动构造函数
  • 函数返回值用引用的好处
    • 在内存中可以产生返回值的副本
    • 注意：不能返回局部变量的引用，因为局部变量在函数结束之后就会被销毁

• 函数传值，传引用，传地址

  • 函数传值：对实参创建一份拷贝，在函数中改变这个值，实参原来的不会被改变
  • 函数传地址：对实参创建一个指针变量，在函数中改变这个值，实参也会改变
  • 函数传引用：没有创建拷贝，没有创建变量，对实参取别名之后，直接对这个量进行修改。

• sizeof

  • sizeof(指针)和sizeof(数组名)的区别

    • 区别1:   sizeof(数组名)大小是整个数组的大小，sizeof(指针)大小是4或者8
    • 区别2：可以为指针取别名，但是不能为数组名取别名
    • 联系：当他们两个作为实参传给指针类型的形参时，大小都为指针的大小，这也是为什么我们在用数组作为实参的时候，还会要传一个数组长度给函数。

    void sizeof_test(double* b) {
    cout << sizeof(b) << endl;
    }
    int main() {
    double a= 0;
    cout <<“double的size:”<< sizeof(a) << endl;
    double b[] = { 1,2,3,4,5 };
    cout <<“数组名的size：”<< sizeof(b) << endl;
    double* c = &a;
    cout <<“指针的size：” <<sizeof© << endl;
    cout << “指针作为实参传给指针类型的形参：”;
    sizeof_test©;
    cout << “数组名作为实参传给指针类型的形参：”;
    sizeof_test(b);
    double& d = a;
    double*& e = c;
    //double*& f = b;错误
    }

    double的size:8
    数组名的size：40
    指针的size：4
    指针作为实参传给指针类型的形参：4
    数组名作为实参传给指针类型的形参：4

    - sizeof(字符数组)
    
    
    	* char a[]="abc"  sizeof(a)=4，因为默认有‘\0’作为结束符
    	* char a[3]="abc" sizeof(a)=3，固定长度,丢失‘\0’
    	* char a[]={'a','b','c'} sizeof(a)=3 丢失‘\0’
    - **sizeof(类)**
    
    
    	* 类的大小只与：非static成员变量以及虚函数有关
    	* 理由：static不是类的某一个实例自己独有的
    	* 构造函数或析构函数
    	
    	
    		+ 1.空类：1
    		+ 2.含有虚函数的类：4
    		+ 3.含有变量的类：取最大的那个
    		+ 4.含有普通函数：1（成员函数不消耗空间）
    
    
    
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21

• class和struct的大小

  • 条件1：成员首地址是其类型的整数倍
  • 条件2：最终大小是最大成员的整数倍
  • 当这两个条件不满足的时候就要进行补位(这不就是字节边界对齐嘛~)

• class和struct的区别

  • 在c++中类和结构体的唯一区别是
    • 默认状态下，类中的成员默认是私有的，结构体中的成员默认是公有的。
  • c++中的结构体和c中的结构体的区别
    • c++中的结构体引入了成员函数，继承，访问控制等面向对象的特性
    • c中的空结构体的大小为0，c++中的空结构体和空类一样，大小是1
    • c++中空类的大小是1的原因
      • 空类可以实例化成不同的对象，不同的对象在内存中的地址不同，所以隐含地加入一个字节来表示不同的对象。

• size和length

  • size是unsigned int；返回容器容量
  • length是int；返回序列容量

• struct 和union

  • struct会给每一个成员变量分配一个内存空间，union所有的成员公用一块内存，只能存储一个被选中的成员的信息。
  • 对struct中的而某一个成员赋值不会影响其他成员的值，但是如果对unioin中的成员赋值，其他所有成员的值都会被重写。
  • 内存分配不同
    • union的大小等于最大的那个类型的成员的大小
    • struct的大小涉及到两个条件：（看上上个回答）

• 大端模式和小端模式

  • 大端模式：低字节存储在高地址
  • 小端模式：低字节存储在低地址
  • 如何判断大端模式，小端模式？用union

  int fun1(){
  union test{
  int a;
  char b
  };
  test t;
  t.a=1;
  return(t.c==1)
  }

   解析：0000 0001左边是高字节，右边是低字节，0x01 0x02 0x03左边是低地址，右边是高地址，如果低字节直接存入高地址，也就是大端模式，那么t.c就是0，如果低字节存入低地址，也就是小端模式，那么t.c就是1
  
  
  
  1
  2
  3
  4

• 构造函数与析构函数

  • 构造函数
    • 有参数，无返回值，用于创建对象的成员函数。
    • 构造函数不能是虚函数
      • 理由：虚函数的执行依赖于虚函数表，虚函数表指针是在构造函数中进行初始化的。如果将构造函数设为虚函数，此时虚函数表指针还没有初始化，所以构造函数不能为虚函数。
  • 析构函数
    • 无参数，无返回值，用于取消对象的成员函数。消除对象，释放内存
    • 析构函数可以虚函数
      • 理由：用父类的指针指向子类对象的情况下，用delete删除对象时，如果析构函数没有被声明为虚函数，此时就只能析构父类对象，不能析构子类对象，这样就会造成内存泄漏。

• 拷贝（复制）构造函数

  • 拷贝构造函数的含义：以一个对象为蓝本，构造另一个对象
  • 拷贝构造函数在什么时候被调用：
    • 复制构造函数不显示调用，都是编译器隐式调用
    • 调用复制构造函数有以下三种情况
      • 1.用一个对象构造另一个函数
        • object a;
        • object b(a);
      • 2.当函数的返回值是对象时，系统自动调用拷贝构造函数
      • 3.对象作为函数的形式参数，调用函数的时候系统自动调用拷贝构造函数
  • 拷贝构造函数的分类
    • 深拷贝：深拷贝是将对象及值复制过来，两个对象修改其中任意的值另一个值不会改变，这就是深拷贝。
    • 浅拷贝：只是复制了对象的引用地址，两个对象指向同一个内存地址，所以修改其中任意的值，另一个值都会随之变化

• 内存泄露

  • 什么叫内存泄漏:因为疏忽或错误造成程序没有释放已经不再使用的内存，导致这一块内存不能够再使用。
  • 出现内存泄漏的情况
    • 疏忽：在用了malloc或者new这样的语句之后，忘记用delete或者free
    • 错误：用了new和delete，但是在new和delete之间，程序出现异常，中断结束，导致delete没有执行。
  • 如何检测内存泄漏？
    • 有一些工具插件可以自己检测
    • c++中一般用crt，#include<crtdbg.h>
    • 在需要检测内存泄漏的地方添加下面这条语句来输出内存泄漏信息：_CrtDumpMemoryLeaks();
    • 在写代码时调用内存申请和释放的统计功能

• 内存溢出：

  • 指程序申请内存时，没有足够的内存供申请者使用，导致数据无法正常存储到内存中。
  • 比如说，给你一个int类型的存储数据大小的空间，但是却存储一个long类型的数据，这样就会导致内存溢出

• Lambda表达式

  • 也叫做匿名函数
  • lambda函数形式：[…] (…) … {…}
    • [] 截取外部变量来使用，可以省
    • () 内是参数，和函数参数一样。
    • … 是mutable, 异常明细
    • {} 内是函数体，在这里面写明lambda要完成的工作。
    • 截取+参数列表+异常声明+函数体
  • lambda表达式使用的场景
    • 当一个函数，你觉得不需要第二次用到它，你就可以把它写成lambda函数，因为你没必要给他起一个名字，只要能实现功能就行。

• define

  • 以#开头的语句都是预处理语句，就是在编译之前干的事情
  • #define 有两种用法
    • 定义一个数值：值的替换
    • 定义一个算式：（不提倡用，很容易出错，不要用！）#define Max(a,b) a>b?a:b(不加分号)
  • define的陷阱
    • define是简单的文本替换，不是赋值
    • #define a 1+2

    int main(){
    cout<<4a<<endl;//输出结果是41+2=6，//如果加上括号的话就没有问题了
    }

     解决办法：
    - 定义一个数值：用const
    - 定义一个表达式：用inline
    
    
    
    1
    2
    3
    4
    5
    6

• inline

  • 目的：引入内联函数的目的是为了解决程序中函数调用的效率问题，程序在编译器编译的时候，编译器将程序中出现的内联函数的调用表达式用内联函数的函数体进行替换，而对于其他的函数，都是在运行时候才被替代。这其实就是个空间代价换时间的节省。所以内联函数一般都是1-5行的小函数。在使用内联函数时要留神：
  • 注意：inline修饰函数的时候要加上函数体，不然没有用。
  • 优点：
    • 执行的速度快
    • 调用时候会检查参数类型，比较安全
    • 可以用来修饰保护成员和私有成员（类中定义的函数不管加不加inline都会是内联函数）
  • 缺点：
    • 以函数复制为代价，如果过多使用，会消耗内存
    • 如果函数体内有循环，那么执行函数代码的时间比调用要开销大
    • 是否内联，程序员不可控。inline只是对编译器的建议，是否内联取决于编译器。

• define和inline的区别

• 

• i++和++i

  • i++是先使用值，再自加；++i是先自增，后使用值
    • i=1;
    • cout<<i++;//结果是1
    • cout<<++i;//结果是2
  • for循环中使用++i和i++的区别
    • 其他地方多是一样的，但是当数据量比较大的时候，使用++i的性能更好
    • 原因：i++，使用完之后，需要有一个临时变量来保存i+1的值,而++i不需要这和临时变量

• volatile

  • 场景：它用来解决变量在“共享”环境下容易出现读取错误的问题。具有以下三个特点：
  • 易变性：
    • 在汇编层面反映出来，就是两条语句，下一条语句不会直接使用上一条语句对应的volatile变量的寄存器内容，而是重新从内存中读取
  • 不可优化性：
    • volatile告诉编译器，不要对我这个变量进行各种激进的优化，保证程序员写在代码中的指令，一定会被执行（不要将a=1直接变成1）
  • 顺序性：
    • volatile变量间的操作，不会被编译器交换顺序

• static

  • 静态全局变量与全局变量的区别
    • 全局变量作用于整个程序
    • 静态全局变量作用于当前源文件
  • 静态局部变量
    • 生命周期：贯穿整个程序执行（只会被初始化一次）static count=0，该变量的值不会因为函数终止而丢失
    • 作用域：和普通局部变量一样
  • 静态数据成员
    • 作用：多个类的对象会共享这个静态成员，实现信息共享
  • 静态成员函数
    • 作用：管理静态数据成员（静态成员函数只能访问静态数据成员，理由是，静态成员函数是属于大家的，不是属于某个类的，他没有this指针）。

• const

  • 定义：用来限定一个变量是只读，不可变，能提高程序的健壮性
  • const和指针
    • 常量指针(const int* )：不能通过指针修改指向的变量的值，但是指针可以转而指向别人（指针可变）
    • 指针常量(int* const p)：可以通过指针修改指向的变量的值，但是指针不能转而指向别人（指针不可变）
  • const和函数
    • 修饰类的成员函数：int func()  const：（注意是在后面加const）函数体内不能修改成员变量的值
    • 修饰函数形参：函数体内不能修改形参
    • 修饰返回值：返回值不能修改
    • const和对象
      • const Point p；只能调用const修饰的成员

• 函数重载，函数重写，函数隐藏

• 

• malloc/free 和new/delete

  • malloc/free

    • 返回值是void *，如果是要其他类型，需要进行强制类型转换

    • 为什么malloc分配内存只需要返回一个指针而不需要返回长度？？

      • 原因：MM(memory menager会将堆中的内存划分不同标号的一段内存分配出去，段与段之间不会重叠)

  • malloc和new的联系

    • 都是为了解决动态分配内存的问题的
    • new和delete底层还是用malloc和free实现的
    • new:malloc分配内存，然后调用构造函数
    • delete:调用析构函数,然后free释放内存

  • malloc和new的区别

    • 本质：new是运算符，malloc是函数
    • 参数：new不需要自己指定申请的内存大小，malloc需要配合sizeof
    • 返回类型：new根据对象的类型返回指针，malloc返回值为void*，要进行强转
    • 内存区域：new从自由存储区为对象分配空间，malloc从堆上分配
    • 重载：new允许重载（所以new的空间不一定在自由存储区，因为可以重载operator new），delete不允许
    • 申请失败：malloc返回null，new会抛出异常
    • 效率：malloc的效率比new快（因为new底层是用malloc实现的）
    • 申请对象：malloc不能为对象申请空间，到那时new可以为任意类型申请空间

  • 为什么有了malloc/free还需要new和delete

    • 因为在为对象申请空间时，除了动态内存分配，还需要调用构造函数进行初始化，不能同时把这两个工作都交给malloc,所以需要new

  • 关于void*

    • 本质：一种不确定类型的指针

    • 赋值

      • 它可以赋值给任意类型的指针，不需要强制类型转换
      • 它可以赋值给任意类型的变量，但是需强制类型转换，且在转换之后就不能转换成其他类型了。

• 内存分配

  • 栈区：局部变量，效率高，操作系统和编译器自动分配，空间有限
  • 堆区：malloc
  • 自由存储区:new，如果程序员忘记释放，在结束后操作系统会自动回收
  • 全局/静态存储区：全局变量和静态变量
  • 常量存储区：常量，不允许修改
  • 另：自由存储区和堆区
    • 区别：
      • 自由存储是c++中通过new/delete动态分配和释放对象的抽象概念
      • 堆是操作系统的概念，是操作系统维护的一段动态分配的内存
    • 联系：在c++中用malloc实现的new,我们也可以说它申请的内存在堆上
  • 另：堆区和栈区的区别
    • 管理方式不同：
      • 堆由程序员管理
      • 栈是由操作系统自动管理
    • 碎片问题：
      • 堆：频繁的new/malloc会造成大量的内存碎片
      • 栈：先入后出的结构，进出一一对应，不会产生内存碎片。
    • 生长方向：
      • 堆向上，向高地址方向增长
      • 栈向下，向低地址方向生长
    • 分配方式：

既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，涵盖了95%以上物联网嵌入式知识点，真正体系化！

由于文件比较多，这里只是将部分目录截图出来，全套包含大厂面经、学习笔记、源码讲义、实战项目、大纲路线、电子书籍、讲解视频，并且后续会持续更新

需要这些体系化资料的朋友，可以加我V获取：vip1024c （备注嵌入式）

如果你需要这些资料，可以戳这里获取

碎片问题：
* 堆：频繁的new/malloc会造成大量的内存碎片
* 栈：先入后出的结构，进出一一对应，不会产生内存碎片。
- 生长方向：
* 堆向上，向高地址方向增长
* 栈向下，向低地址方向生长
- 分配方式：

[外链图片转存中…(img-JRlGIWgz-1715796940345)]
[外链图片转存中…(img-oS5cHAE8-1715796940345)]

既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，涵盖了95%以上物联网嵌入式知识点，真正体系化！

由于文件比较多，这里只是将部分目录截图出来，全套包含大厂面经、学习笔记、源码讲义、实战项目、大纲路线、电子书籍、讲解视频，并且后续会持续更新

需要这些体系化资料的朋友，可以加我V获取：vip1024c （备注嵌入式）

如果你需要这些资料，可以戳这里获取