【c++】经典面试题吐血整理

c++经典面试题，开始吧~~

• 程序从源程序到生成可执行文件的过程

  • 1.编程
  • 2.编译预处理：处理宏定义，头文件，特殊符号之类的
  • 3.编译：处理关键字，确认所有指令是否符合语法
  • 4.优化：删除公共表达式，循环优化之类的，优化之后得到汇编程序
  • 5.汇编：将汇编程序翻译成目标机器指令
  • 6.链接：将多个目标文件及所需要的库连接成最终的可执行目标文件
    • 静态链接：
      • 时机：在形成可执行文件之前链接
      • 过程：将函数对应的目标文件要一份副本，将所有的程序模块连接成一个单独的可执行文件
      • 优点：执行速度快
      • 缺点：浪费空间（同一个目标文件在内存中可能存在多个副本），更新困难，当库函数的库函数代码修改时，需要重新编译链接
    • 动态链接：
      • 时机：在程序执行时链接
      • 过程：把程序按照模块拆分成多个相对独立的部分，在程序运行的时候才将他们连接在一起形成一个完整的程序。
      • 优点：不会出现副本重复加载，从而不会浪费内存空间，更新比较方便
      • 缺点：程序运行的时候需要进行链接，所以程序的性能会有一定损失。
  • 7.可执行文件
  • 从考试的角度还可以这样回答
  • 
  • 编译将高级语言翻译成机器语言，形成多个目标模块，链接将多个目标模块组合形成完成的逻辑地址，装入将逻辑地址转换为物理地址。其中，链接有三种方式，装入也有三种方式。

• include头文件

  • 头文件的顺序

    • 对于include的头文件来说，如果在文件a.h中声明一个在文件b.h中定义的变量，而不引用b.h。那么要在a.c文件中引用b.h文件，并且要先引用b.h，后引用a.h,否则汇报变量类型未声明错误。

  • 头文件双引号和尖括号的区别

    • 查找头文件的顺序不同

      • 双引号

        • 当前头文件目录（用户目录）

        • 编译器设置的头文件路径

        • 系统变量CPLUS_INCLUDE_PATH/C_INCLUDE_PATH指定的头文件路径

      • 尖括号

        • 编译器设置的头文件变量

        • 系统变量指定的路径

• c++面向对象的三大特性

  • 封装

  • 继承

  • 多态

• c++11新特性

  • 关联容器中的无序容器
  • forword_list
  • auto 自动类型推导
  • 序列for循环
  • lambda表达式
  • nullptr
  • 右值引用

• C++和C#的区别

  • c#没有指针
  • c#不支持多继承
  • c#有自动垃圾回收机制，不需要程序员做内存管理
  • c#的switch语句会排除所有失败的情形，并且switch中允许string型(c++只允许int)
  • c#一般用于企业应用程序开发，c++适合底层开发（游戏等）

• STL

  • vector
    • 动态数组：为了实现动态，有的编译器会默认为vector生成一个长度，当插入的元素的个数大于该长度时，就会生成一个长度为原长度二倍的数组，并将原来数组的数据拷贝在新数组中。支持随机访问，但是插入删除效率低
  • list:
    • 双向链表，不支持下标访问；插入删除的效率高
  • deque
    • 双向队列，是可实现双向插入数据的动态数组。为了实现双向插入删除的功能，编译器一般会把其数据结构设置成一段一段的数组，每段数组链接起来构成一个超级大链。如果前面的某一段被填满了，就会在大链表的前面生成一段数组，如果后面的数组填满了，也一样。支持下标访问，插入删除和随机访问的效率都是list和vector的折中。
  • set, multiset:
    • 分别实现的是无重复元素的集合和有重复元素的集合。一般由红黑树实现
  • map,multimap: 分别实现的是1：1（没有重复元素的键值对）的映射关系，和有1：N（键值对中的而键值可以重复）的映射关系。一般由红黑树实现。（红黑树：自平衡的二叉排序树）

• STL容器分类：

  • 关联容器
    • 无序容器:   如果需要很快的查询效率：c++11:(散列表)unorder_set,multiset,map,multimap
    • 有序容器：如果需要有序：（红黑树）set,multiset,map.multimap
  • 顺序容器(数据结构中的“顺序”是相对链式而言的，c++中的“顺序”是相对关联来说的)
    • （string）
    • vector
    • list
    • (forward_list)
    • deque

• 什么是多态性

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

  • 不同类的对象对同一个消息的响应
  • 多态性是一种泛型技术（用不变的代码实现可变的算法）
  • 实现多态的条件是
    • 1.有类的继承关系，且继承关系中的每一个类都有虚函数
    • 2.用父类的指针指向子类的对象
    • 3.用父类的指针来调用子类对象中的成员函数

• 虚函数

  • 用virtual关键字说明的函数
  • 是实现多态性的基础
  • 注意：
    • 构造函数不能是虚函数 https://blog.csdn.net/qq_39328436/article/details/113405539
    • 虚析构函数
    • 类的静态成员函数不能是虚函数（静态成员函数是所有）
    • 内联函数不能是虚函数：inline是编译器将函数内容替换到函数调用的地方，是静态编译的，但是虚函数动态调用的，是只有在函数运行的时候才能知道调用的是哪个函数，所以在编译的时候，incline它不知道是子类函数父类的虚函数，因此编译器会忽略。

• 虚函数表

  • 定义：虚函数表是一个类的虚函数的地址表，每个对象在创建时，都会有一个指针指向该类虚函数表。
  • 作用：在用父类的指针调用子类对象成员函数时，虚函数表会指明要调用的具体函数是哪个。
  • 原理：每一个类的虚函数表，按照函数声明的顺序，会将函数地址存在虚函数表中，当子类对象重写父类的虚函数的时候，父类的虚函数表中对应的位置会被子类的虚函数地址覆盖。
  • 局限性：当父类的虚函数是非public时，它依然会存在在虚函数表中，所以可以通过虚函数指针来访

• 智能指针

  • 共三种：shared_ptr ,unique_ptr,weak_ptr(auto_ptr在c++11中被禁用)
    • shared_ptr:多个指针指向相同的对象，std::shared_ptr的大小：是原始指针的两倍，因为它的内部有一个原始指针指向资源，同时有个指针指向引用计数。
    • unique_ptr:唯一拥有所指对象
    • weak_ptr:是为了配合shared_ptr而引入的智能指针，为了避免shared_ptr相互指向产生环形结构。
  • 头文件：memery
  • 引用智能指针的目的
    • 程序员不用手动释放资源，方便内存管理
    • 利用了RAII（资源获取既初始化）的技术对普通指针进行封装，这使智能指针表现为一个指针但是实质却是一个对象。

• 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(字符数组)

      • 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（成员函数不消耗空间）

• 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

• 构造函数与析构函数

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

• 拷贝（复制）构造函数

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

• 内存泄露

  • 什么叫内存泄漏:因为疏忽或错误造成程序没有释放已经不再使用的内存，导致这一块内存不能够再使用。
  • 出现内存泄漏的情况
    • 疏忽：在用了malloc或者new这样的语句之后，忘记用delete或者free
    • 错误：用了new和delete，但是在new和delete之间，程序出现异常，中断结束，导致delete没有执行。
  • 如何检测内存泄漏？
    • 有一些工具插件可以自己检测
    • c++中一般用crt，#include
    • 在需要检测内存泄漏的地方添加下面这条语句来输出内存泄漏信息：_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<<4*a<

      解决办法：

    • 定义一个数值：用const

    • 定义一个表达式：用inline

• inline

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

• define和inline的区别

• 

• i++和++i

  • i++是先使用值，再自加；++i是先自增，后使用值
    • i=1;
    • cout<
    • 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会造成大量的内存碎片
      • 栈：先入后出的结构，进出一一对应，不会产生内存碎片。
    • 生长方向：
      • 堆向上，向高地址方向增长
      • 栈向下，向低地址方向生长
    • 分配方式：
      • 堆是动态分配，没有静态分配
      • 栈中有静态分配也有动态分配，静态分配是由编译器完成，动态分配由alloca函数分配，编译器自动释放，无需程序员实现。
    • 空间大小：
      • 堆是不连续的内存空间（用链表来存储空闲内存地址），空间大。
      • 栈和数据结构中的栈一样，是一块连续的内存空间，空间小

C艹好难!