C/C++面试常考知识点

C/C++基础部分C++和C的区别设计思想上：C++是面向对象的语言，而C是面向过程的结构化编程语言。语法上：C++具有封装、继承和多态三种特性；C++相比C，增加多许多类型安全的功能，比如强制类型转换、C++支持范式编程，比如模板类、函数模板等。C++中static关键字的作用全局静态变量在全局变量前加上关键字static，全局变量就定义成一个全局静态变量。静态存储区，在整个程序运行期间一直存在

Tavi_

6717人浏览 · 2020-08-12 16:19:24

Tavi_ · 2020-08-12 16:19:24 发布

笔试面试准备合集

算法面试常考知识点
 计算机网络面试常考知识点
 Linux面试常考知识点
 操作系统面试常考知识点
 C/C++面试常考知识点

一、C/C++基础部分

C++和C的区别

设计思想上：
C++是面向对象的语言，而C是面向过程的结构化编程语言。
语法上：
C++具有封装、继承和多态三种特性；
C++相比C，增加多许多类型安全的功能，比如强制类型转换（static_cast、const_cast、reinterpret_cast和dynamic_cast）
C++支持范式编程，比如模板类、函数模板等。

面向对象与面向过程的区别

面向对象与面向过程语言的区别

static关键字的作用

全局静态变量
在全局变量前加上关键字static，全局变量就定义成一个全局静态变量。
静态存储区，在整个程序运行期间一直存在。
初始化：未经初始化的全局静态变量会被自动初始化为0（自动对象的值是任意的，除非他被显式初始化）。
作用域：全局静态变量在声明他的文件之外是不可见的，准确地说是从定义之处开始，到文件结尾。
局部静态变量
在局部变量之前加上关键字static，局部变量就成为一个局部静态变量。
内存中的位置：静态存储区。
初始化：未经初始化的全局静态变量会被自动初始化为0（自动对象的值是任意的，除非他被显式初始化）。
作用域：作用域仍为局部作用域，当定义它的函数或者语句块结束的时候，作用域结束。但是当局部静态变量离开作用域后，并没有销毁，而是仍然驻留在内存当中，只不过我们不能再对它进行访问，直到该函数再次被调用，并且值不变。
静态函数
在函数返回类型前加static，函数就定义为静态函数。函数的定义和声明在默认情况下都是extern的，但静态函数只是在声明他的文件当中可见，不能被其他文件所用。
函数的实现使用static修饰，那么这个函数只可在本cpp内使用，不会同其他cpp中的同名函数引起冲突。
warning：不要再头文件中声明static的全局函数，不要在cpp内声明非static的全局函数，如果你要在多个cpp中复用该函数，就把它的声明提到头文件里去，否则cpp内部声明需加上static修饰。
类的静态成员
在类中，静态成员可以实现多个对象之间的数据共享，并且使用静态数据成员还不会破坏隐藏的原则，即保证了安全性。因此，静态成员是类的所有对象中共享的成员，而不是某个对象的成员。对多个对象来说，静态数据成员只存储一处，供所有对象共用。
类的静态函数
静态成员函数和静态数据成员一样，它们都属于类的静态成员，它们都不是对象成员。因此，对静态成员的引用不需要用对象名。
在静态成员函数的实现中不能直接引用类中说明的非静态成员，可以引用类中说明的静态成员（这点非常重要）。如果静态成员函数中要引用非静态成员时，可通过对象来引用。从中可看出，调用静态成员函数使用如下格式：<类名>::<静态成员函数名>(<参数表>);

简洁回答：（推荐）
① 加了 static 关键字的全局变量只能在本文件中使用。
例如在 a.c 中定义了 static int a=10;那么在 b.c 中用extern int a 是拿不到 a 的值得，a 的作用域只在 a.c 中。
② static 定义的静态局部变量分配在数据段上，普通的局部变量分配在栈上，会因为函数栈帧的释放而被释放掉。
③ 对一个类中成员变量和成员函数来说，加了 static 关键字，则此变量/函数就没有了 this 指针了，必须通过类名才能访问

const关键字的作用

在这里插入图片描述

extern关键字的作用

extern修饰变量的声明。举例来说，如果文件a.c需要引用b.c中变量int v，就可以在a.c中声明extern int v，然后就可以引用变量v。这里需要注意的是，被引用的变量v的链接属性必须是外链接（external）的，也就是说a.c要引用到v，不只是取决于在a.c中声明extern int v，还取决于变量v本身是能够被引用到的。这涉及到c语言的另外一个话题－－变量的作用域。能够被其他模块以extern修饰符引用到的变量通常是全局变量。还有很重要的一点是，extern int v可以放在a.c中的任何地方，比如你可以在a.c中的函数fun定义的开头处声明extern int v，然后就可以引用到变量v了，只不过这样只能在函数fun作用域中引用v罢了，这还是变量作用域的问题。对于这一点来说，很多人使用的时候都心存顾虑。好像extern声明只能用于文件作用域似的。
extern修饰函数声明。从本质上来讲，变量和函数没有区别。函数名是指向函数二进制块开头处的指针。如果文件a.c需要引用b.c中的函数，比如在b.c中原型是int fun(int mu)，那么就可以在a.c中声明extern int fun（int mu），然后就能使用fun来做任何事情。就像变量的声明一样，extern int fun（int mu）可以放在a.c中任何地方，而不一定非要放在a.c的文件作用域的范围中。对其他模块中函数的引用，最常用的方法是包含这些函数声明的头文件。
此外，extern修饰符可用于指示C或者C++函数的调用规范。比如在C++中调用C库函数，就需要在C++程序中用extern “C”声明要引用的函数。这是给链接器用的，告诉链接器在链接的时候用C函数规范来链接。主要原因是C++和C程序编译完成后在目标代码中命名规则不同。

C/C++中extern的用法

volatile关键字的作用

有些变量是用volatile关键字声明的。当两个线程都要用到某一个变量且该变量的值会被改变时，应该用volatile声明，该关键字的作用是防止优化编译器把变量从内存装入CPU寄存器中。如果变量被装入寄存器，那么两个线程有可能一个使用内存中的变量，一个使用寄存器中的变量，这会造成程序的错误执行。
volatile的意思是让编译器每次操作该变量时一定要从内存中真正取出，而不是使用已经存在寄存器中的值。
C/C++中volatile关键字详解

C++中volatile关键字的作用

c++中四种cast转换

C++中四种类型转换是：static_cast, dynamic_cast, const_cast, reinterpret_cast

const_cast
用于将const变量转为非const
static_cast
用于各种隐式转换，比如非const转const，void*转指针等, static_cast能用于多态向上转化，如果向下转能成功但是不安全，结果未知；
dynamic_cast
用于动态类型转换。只能用于含有虚函数的类，用于类层次间的向上和向下转化。只能转指针或引用。向下转化时，如果是非法的对于指针返回NULL，对于引用抛异常。要深入了解内部转换的原理。
向上转换：指的是子类向基类的转换
向下转换：指的是基类向子类的转换
它通过判断在执行到该语句的时候变量的运行时类型和要转换的类型是否相同来判断是否能够进行向下转换。
reinterpret_cast
几乎什么都可以转，比如将int转指针，可能会出问题，尽量少用；

注意：为什么不使用C的强制转换？
C的强制转换表面上看起来功能强大什么都能转，但是转化不够明确，不能进行错误检查，容易出错。

struct和class的区别

sizeof和strlen的区别

strlen 与 sizeof 的区别

c++中的四个智能指针

C++ STL 四种智能指针
 C++11的智能指针简介

智能指针主要用于管理在堆上分配的内存，它将普通的指针封装为一个栈对象。当栈对象的生存周期结束后，会在析构函数中释放掉申请的内存，从而防止内存泄漏。C++ 11中最常用的智能指针类型为shared_ptr,它采用引用计数的方法，记录当前内存资源被多少个智能指针引用。该引用计数的内存在堆上分配。当新增一个时引用计数加1，当过期时引用计数减一。只有引用计数为0时，智能指针才会自动释放引用的内存资源。对shared_ptr进行初始化时不能将一个普通指针直接赋值给智能指针，因为一个是指针，一个是类。可以通过make_shared函数或者通过构造函数传入普通指针。并可以通过get函数获得普通指针。

C++里面的四个智能指针: auto_ptr, shared_ptr, weak_ptr, unique_ptr 其中后三个是c++11支持，并且第一个已经被11弃用。

为什么要使用智能指针?
智能指针的作用是管理一个指针，因为存在以下这种情况：申请的空间在函数结束时忘记释放，造成内存泄漏。使用智能指针可以很大程度上的避免这个问题，因为智能指针就是一个类，当超出了类的作用域是，类会自动调用析构函数，析构函数会自动释放资源。所以智能指针的作用原理就是在函数结束时自动释放内存空间，不需要手动释放内存空间。

auto_ptr（c++98的方案，cpp11已经抛弃）
采用所有权模式。

auto_ptr< string> p1 (new string ("I reigned lonely as a cloud.”));
auto_ptr<string> p2;
p2 = p1; //auto_ptr不会报错.

此时不会报错，p2剥夺了p1的所有权，但是当程序运行时访问p1将会报错。所以auto_ptr的缺点是：存在潜在的内存崩溃问题！

unique_ptr（替换auto_ptr）
unique_ptr实现独占式拥有或严格拥有概念，保证同一时间内只有一个智能指针可以指向该对象。它对于避免资源泄露(例如“以new创建对象后因为发生异常而忘记调用delete”)特别有用。
采用所有权模式，还是上面那个例子

unique_ptr<string> p3 (new string ("auto"));   //#4
unique_ptr<string> p4；                       //#5
p4 = p3;//此时会报错！！

编译器认为p4=p3非法，避免了p3不再指向有效数据的问题。因此，unique_ptr比auto_ptr更安全。
另外unique_ptr还有更聪明的地方：当程序试图将一个 unique_ptr 赋值给另一个时，如果源 unique_ptr 是个临时右值，编译器允许这么做；如果源 unique_ptr 将存在一段时间，编译器将禁止这么做，比如：

unique_ptr<string> pu1(new string ("hello world"));
unique_ptr<string> pu2;
pu2 = pu1;                                      // #1 not allowed
unique_ptr<string> pu3;
pu3 = unique_ptr<string>(new string ("You"));   // #2 allowed

其中#1留下悬挂的unique_ptr(pu1)，这可能导致危害。而#2不会留下悬挂的unique_ptr，因为它调用 unique_ptr 的构造函数，该构造函数创建的临时对象在其所有权让给 pu3 后就会被销毁。这种随情况而已的行为表明，unique_ptr 优于允许两种赋值的auto_ptr 。

注：如果确实想执行类似与#1的操作，要安全的重用这种指针，可给它赋新值。C++有一个标准库函数std::move()，让你能够将一个unique_ptr赋给另一个。例如：

unique_ptr<string> ps1, ps2;
ps1 = demo("hello");
ps2 = move(ps1);
ps1 = demo("alexia");
cout << *ps2 << *ps1 << endl;

shared_ptr
shared_ptr实现共享式拥有概念。多个智能指针可以指向相同对象，该对象和其相关资源会在“最后一个引用被销毁”时候释放。从名字share就可以看出了资源可以被多个指针共享，它使用计数机制来表明资源被几个指针共享。可以通过成员函数use_count()来查看资源的所有者个数。除了可以通过new来构造，还可以通过传入auto_ptr, unique_ptr,weak_ptr来构造。当我们调用release()时，当前指针会释放资源所有权，计数减一。当计数等于0时，资源会被释放。
shared_ptr 是为了解决 auto_ptr 在对象所有权上的局限性(auto_ptr 是独占的), 在使用引用计数的机制上提供了可以共享所有权的智能指针。
成员函数：
use_count 返回引用计数的个数
unique 返回是否是独占所有权( use_count 为 1)
swap 交换两个 shared_ptr 对象(即交换所拥有的对象)
reset 放弃内部对象的所有权或拥有对象的变更, 会引起原有对象的引用计数的减少
get 返回内部对象(指针), 由于已经重载了()方法, 因此和直接使用对象是一样的。
如 shared_ptr sp(new int(1)); sp 与 sp.get()是等价的
weak_ptr
weak_ptr 是一种不控制对象生命周期的智能指针, 它指向一个 shared_ptr 管理的对象. 进行该对象的内存管理的是那个强引用的 shared_ptr. weak_ptr只是提供了对管理对象的一个访问手段。weak_ptr 设计的目的是为配合 shared_ptr 而引入的一种智能指针来协助 shared_ptr 工作, 它只可以从一个 shared_ptr 或另一个 weak_ptr 对象构造, 它的构造和析构不会引起引用记数的增加或减少。weak_ptr是用来解决shared_ptr相互引用时的死锁问题,如果说两个shared_ptr相互引用,那么这两个指针的引用计数永远不可能下降为0,资源永远不会释放。它是对对象的一种弱引用，不会增加对象的引用计数，和shared_ptr之间可以相互转化，shared_ptr可以直接赋值给它，它可以通过调用lock函数来获得shared_ptr。

class B;
class A
{
public:
	shared_ptr<B> pb_;
	~A()
	{
		cout<<"A delete\n";
	}
};

class B
{
public:
	shared_ptr<A> pa_;
	~B()
	{
		cout<<"B delete\n";
	}
};
void fun()
{
	shared_ptr<B> pb(new B());
	shared_ptr<A> pa(new A());
	pb->pa_ = pa;
	pa->pb_ = pb;
	cout<<pb.use_count()<<endl;
	cout<<pa.use_count()<<endl;
}

int main()
{
	fun();
	return 0;
}

可以看到fun函数中pa ，pb之间互相引用，两个资源的引用计数为2，当要跳出函数时，智能指针pa，pb析构时两个资源引用计数会减一，但是两者引用计数还是为1，导致跳出函数时资源没有被释放（A B的析构函数没有被调用），如果把其中一个改为weak_ptr就可以了，我们把类A里面的shared_ptr pb_; 改为weak_ptr pb_; 运行结果如下，这样的话，资源B的引用开始就只有1，当pb析构时，B的计数变为0，B得到释放，B释放的同时也会使A的计数减一，同时pa析构时使A的计数减一，那么A的计数为0，A得到释放。

注意的是我们不能通过weak_ptr直接访问对象的方法，比如B对象中有一个方法print(),我们不能这样访问，pa->pb_->print(); 英文pb_是一个weak_ptr，应该先把它转化为shared_ptr,如：shared_ptr p = pa->pb_.lock(); p->print();

C++四种强制类型转化

C++四种强制类型转换详解

C++ 四种强制类型转换

内存泄漏怎么处理的

内存泄露：
什么是内存泄露？
当我们用new或者malloc申请了内存，但是没有用delete或者free及时的释放了内存，结果导致一直占据该内存。内存泄漏形象的比喻是“操作系统可提供给所有进程的存储空间被某个进程榨干”，最终结果是程序运行时间越长，占用存储空间越来越多，最终用尽全部存储空间，整个系统崩溃。
程序退出以后，能不能回收内存？
程序结束后，会释放其申请的所有内存，这样是可以解决问题。但是你的程序还是有问题的，就如你写了一个函数，申请了一块内存，但是没有释放，每调用一次你的函数就会白白浪费一些内存。如果你的程序不停地在运行，就会有很多的内存被浪费，最后可能你的程序会因为用掉内存太多而***作系统杀死。
智能指针：Effective C++ 建议我们将对象放到智能指针里，可以有效的避免内存泄露。

什么是智能指针？
一种类似指针的数据类型，将对象存储在智能指针中，可以不需要处理内存泄露的问题，它会帮你调用对象的析构函数自动撤销对象（主要是智能指针自己的析构函数用了delete ptr，delete会自动调用指针对象的析构函数，前提该内存是在堆上的，如果是在栈上就会出错），释放内存。因此，你要做的就是在析构函数中释放掉数据成员的资源。

为了解决循环引用导致的内存泄漏，引入了weak_ptr弱指针，weak_ptr的构造函数不会修改引用计数的值，从而不会对对象的内存进行管理，其类似一个普通指针，但不指向引用计数的共享内存，但是其可以检测到所管理的对象是否已经被释放，从而避免非法访问。

野指针

野指针就是指向一个已删除的对象或者未申请访问受限内存区域的指针。

数组和指针的区别

在这里插入图片描述

c/c++中的引用和指针

定义

1. 引用：
C++是C语言的继承，它可进行过程化程序设计，又可以进行以抽象数据类型为特点的基于对象的程序设计，还可以进行以继承和多态为特点的面向对象的程序设计。引用就是C++对C语言的重要扩充。引用就是某一变量的一个别名，对引用的操作与对变量直接操作完全一样。引用的声明方法：类型标识符 &引用名=目标变量名；引用引入了对象的一个同义词。定义引用的表示方法与定义指针相似，只是用&代替了*。
引用注意：

引用必须被初始化；
引用不能改变绑定的对象；
引用只有一级；

2. 指针：
指针利用地址，它的值直接指向存在电脑存储器中另一个地方的值。由于通过地址能找到所需的变量单元，可以说，地址指向该变量单元。因此，将地址形象化的称为“指针”。意思是通过它能找到以它为地址的内存单元。

指针使用注意事项：

初始化时要置空；
使用时要考虑指向对象边界问题；
不能对未初始化的指针取值或赋值；
释放时要置空；
如果返回动态分配内存或对象，必须使用指针；

区别

指针有自己的一块空间，而引用只是一个别名；
使用sizeof看一个指针的大小是4，而引用则是被引用对象的大小；
指针可以被初始化为NULL，而引用必须被初始化且必须是一个已有对象的引用；
作为参数传递时，指针需要被解引用才可以对对象进行操作，而直接对引用的修改都会改变引用所指向的对象；
可以有const指针，但是没有const引用；
指针在使用中可以指向其它对象，但是引用只能是一个对象的引用，不能被改变；
指针可以有多级指针（**p），而引用至于一级；
指针和引用使用++运算符的意义不一样；
如果返回动态内存分配的对象或者内存，必须使用指针，引用可能引起内存泄露。

虚函数和析构函数

C++中析构函数的作用

析构函数与构造函数对应，当对象结束其生命周期，如对象所在的函数已调用完毕时，系统会自动执行析构函数。
析构函数名也应与类名相同，只是在函数名前面加一个位取反符_，例如stud( )，以区别于构造函数。它不能带任何参数，也没有返回值（包括void类型）。只能有一个析构函数，不能重载。
如果用户没有编写析构函数，编译系统会自动生成一个缺省的析构函数（即使自定义了析构函数，编译器也总是会为我们合成一个析构函数，并且如果自定义了析构函数，编译器在执行时会先调用自定义的析构函数再调用合成的析构函数），它也不进行任何操作。所以许多简单的类中没有用显式的析构函数。
如果一个类中有指针，且在使用的过程中动态的申请了内存，那么最好显示构造析构函数在销毁类之前，释放掉申请的内存空间，避免内存泄漏。
类析构顺序：1）派生类本身的析构函数；2）对象成员析构函数；3）基类析构函数。

C++虚函数实现原理
 从内存布局看C++虚继承的实现原理

静态函数和虚函数的区别

静态函数在编译的时候就已经确定运行时机，虚函数在运行的时候动态绑定。虚函数因为用了虚函数表机制，调用的时候会增加一次内存开销

为什么析构函数必须是虚函数？C++默认的析构函数不是虚函数？

将可能会被继承的父类的析构函数设置为虚函数，可以保证当我们new一个子类，然后使用基类指针指向该子类对象，释放基类指针时可以释放掉子类的空间，防止内存泄漏。

C++默认的析构函数不是虚函数是因为虚函数需要额外的虚函数表和虚表指针，占用额外的内存。而对于不会被继承的类来说，其析构函数如果是虚函数，就会浪费内存。因此C++默认的析构函数不是虚函数，而是只有当需要当作父类时，设置为虚函数。

深拷贝与浅拷贝

c++深拷贝和浅拷贝

C++封装、多态、继承

C++的三大特性：封装、继承和多态性的详解

重载和覆盖

重载：两个函数名相同，但是参数列表不同（个数，类型），返回值类型没有要求，在同一作用域中
重写：子类继承了父类，父类中的函数是虚函数，在子类中重新定义了这个虚函数，这种情况是重写。

虚函数和多态

多态的实现主要分为静态多态和动态多态，静态多态主要是重载，在编译的时候就已经确定；动态多态是用虚函数机制实现的，在运行期间动态绑定。

举个例子：一个父类类型的指针指向一个子类对象时候，使用父类的指针去调用子类中重写了的父类中的虚函数的时候，会调用子类重写过后的函数，在父类中声明为加了virtual关键字的函数，在子类中重写时候不需要加virtual也是虚函数。

虚函数的实现：在有虚函数的类中，类的最开始部分是一个虚函数表的指针，这个指针指向一个虚函数表，表中放了虚函数的地址，实际的虚函数在代码段(.text)中。当子类继承了父类的时候也会继承其虚函数表，当子类重写父类中虚函数时候，会将其继承到的虚函数表中的地址替换为重新写的函数地址。使用了虚函数，会增加访问内存开销，降低效率。

函数指针

1、定义
函数指针是指向函数的指针变量。
函数指针本身首先是一个指针变量，该指针变量指向一个具体的函数。这正如用指针变量可指向整型变量、字符型、数组一样，这里是指向函数。

C在编译时，每一个函数都有一个入口地址，该入口地址就是函数指针所指向的地址。有了指向函数的指针变量后，可用该指针变量调用函数，就如同用指针变量可引用其他类型变量一样，在这些概念上是大体一致的。

2、用途：
调用函数和做函数的参数，比如回调函数。

3、示例：

char * fun(char * p)  {…}       // 函数fun
char * (*pf)(char * p);             // 函数指针pf
pf = fun;                        // 函数指针pf指向函数fun
pf(p);                        // 通过函数指针pf调用函数fun

fork、wait和exec函数

Fork：创建一个和当前进程映像一样的进程可以通过fork( )系统调用：

#include <sys/types.h>
#include <unistd.h>
pid_t fork(void);

成功调用fork( )会创建一个新的进程，它几乎与调用fork( )的进程一模一样，这两个进程都会继续运行。在子进程中，成功的fork( )调用会返回0。在父进程中fork( )返回子进程的pid。如果出现错误，fork( )返回一个负值。
最常见的fork( )用法是创建一个新的进程，然后使用exec( )载入二进制映像，替换当前进程的映像。这种情况下，派生（fork）了新的进程，而这个子进程会执行一个新的二进制可执行文件的映像。这种“派生加执行”的方式是很常见的。
在早期的Unix系统中，创建进程比较原始。当调用fork时，内核会把所有的内部数据结构复制一份，复制进程的页表项，然后把父进程的地址空间中的内容逐页的复制到子进程的地址空间中。但从内核角度来说，逐页的复制方式是十分耗时的。现代的Unix系统采取了更多的优化，例如Linux，采用了写时复制的方法，而不是对父进程空间进程整体复制。

父进程产生子进程使用fork拷贝出来一个父进程的副本，此时只拷贝了父进程的页表，两个进程都读同一块内存，当有进程写的时候使用写实拷贝机制分配内存，exec函数可以加载一个elf文件去替换父进程，从此父进程和子进程就可以运行不同的程序了。fork从父进程返回子进程的pid，从子进程返回0.调用了wait的父进程将会发生阻塞，直到有子进程状态改变,执行成功返回0，错误返回-1。

隐式类型转换

类型转换

reinterpret_cast：可以用于任意类型的指针之间的转换，对转换的结果不做任何保证
dynamic_cast：这种其实也是不被推荐使用的，更多使用static_cast，dynamic本身只能用于存在虚函数的父子关系的强制类型转换，对于指针，转换失败则返回nullptr，对于引用，转换失败会抛出异常
const_cast：对于未定义const版本的成员函数，我们通常需要使用const_cast来去除const引用对象的const，完成函数调用。另外一种使用方式，结合static_cast，可以在非const版本的成员函数内添加const，调用完const版本的成员函数后，再使用const_cast去除const限定。
static_cast：完成基础数据类型；同一个继承体系中类型的转换；任意类型与空指针类型void* 之间的转换。

隐式类型转换

首先，对于内置类型，低精度的变量给高精度变量赋值会发生隐式类型转换，其次，对于只存在单个参数的构造函数的对象构造来说，函数调用可以直接使用该参数传入，编译器会自动调用其构造函数生成临时对象。

new/delete与malloc/free区别（重点）

new/delete是C++的关键字，而malloc/free是C语言的库函数，后者使用必须指明申请内存空间的大小，对于类类型的对象，后者不会调用构造函数和析构函数；
malloc需要给定申请内存的大小，返回的指针需要强转。
new会调用构造函数，不用指定内存大小，返回的指针不用强转。

new/delete与malloc/free的区别与联系

浅谈new/delete和malloc/free的用法与区别

在这里插入图片描述

C/C++ 源文件从文本到可执行文件经历的过程

对于C/C++源文件，从文本到可执行文件一般需要四个过程：

预处理阶段：对源代码文件中文件包含关系（头文件）、预编译语句（宏定义）进行分析和替换，生成预编译文件。
相关命令：gcc -E man.c -o main.i

编译阶段：将经过预处理后的预编译文件转换成特定汇编代码，生成汇编文件。
相关命令：gcc -S man.i -o main.s

汇编阶段：将编译阶段生成的汇编文件转化成机器码，生成可重定位目标文件。
相关命令：gcc -c man.s -o main.o

链接阶段：将多个目标文件及所需要的库连接成最终的可执行目标文件。
相关命令：gcc man.o -o main

RTTI

RTTI (Run Time Type Identification) 指的是运行时类型识别。程序能够使用基类的指针或引来检查这些指针或引用所指的对象的实际派生类型。

RTTI提供了两个非常有用的操作符：typeid 和 dynamic_cast。

① typeid操作符：返回指针和引用所指的实际类型，返回类型为 type_info。
关于 typeid 的注意事项：
typeid 返回一个 type_info 的对象引用。
如果想通过基类的指针指向派生类的数据类型，基类就必须要带有虚函数，否则，在使用typeid 时，就只能返回定义时所使用的数据类型。
typeid 只能获取对象的实际类型，即便这个类含有虚函数，也只能判断当前对象是基类还是派生类，而不能判断当前指针是基类还是派生类。

② dynamic_cast操作符：将基类类型的指针或引用安全地转换为其派生类类型的指针或引用。
关于 dynamic_cast 的注意事项：
只能应用与指针和引用的转换，即只能转化为某一个类型的指针或某一个类型的引用，而不能是某类型本身。
要转化的类型中必须包含虚函数，如果没有虚函数，转换就会失败。
如果转换成功，返回子类的地址，如果转换失败，返回NULL。

虚函数的实现—虚表，怎么实现了多态？

虚表vftable，编译器为每个拥有虚函数的类都建有一张虚函数表，里面存有虚函数的入口指针（地址）。在类对象的内存布局中，先是一个vfptr虚表指针，指向虚表首地址，而后通过偏移量的形式来访问虚表中的地址。

发生单继承时，派生类内存布局，先是复制一份基类内存布局，然后是自己的布局（注意内存对齐）。虚表指针指向自己的虚表，派生类虚函数地址如果自己未覆盖，那么就是基类的，否则是自己的函数地址。

发生多继承时：先按照继承顺序，从左到右排布基类的布局包括虚标指针，然后排布自己的指针和数据；派生类虚表排布形式是按照继承顺序，是继承来的虚函数，如果有覆盖则换成自己的函数地址；然后是下一个基类，直至基类排布完毕。多张虚表各自独立。

发生虚继承时：无论是对象内存排布还是虚表，虚基类的部分都被放到最后排布。

举个例子

/**
	虚继承（虚基类）
*/
 
#include <iostream>
 
// 基类A
class A
{
public:
	int dataA;
};
 
class B : virtual public A
{
public:
	int dataB;
};
 
class C : virtual public A
{
public:
	int dataC;
};
 
class D : public B, public C
{
public:
	int dataD;
};

我们看看B、C、D类的内存布局情况：
在这里插入图片描述

https://blog.csdn.net/xiejingfa/article/details/48028491

C++类成员访问权限

三种public、private、protect:

private成员只能在类内访问，类外不可访问，派生类内不可见，对象不可访问；
protect成员类内可访问，派生类内可访问，对象不可访问；
public：类内、派生类内、对象也可访问。

右值与左值，右值引用？用法？

左值和左值引用我们很熟悉了。一般定义的变量/对象都是左值，可以被赋值，直到作用域结束才释放。左值引用相当于左值的别名，可以通过它修改左值。可以被赋值

右值不同于左值，它是临时值（比如表达式结果-汇编里是立即数），用完就被抛弃释放，又称将亡值，我觉得很是贴切。不可被赋值。

右值引用就是右值的引用，可以实现右值的持久化，可以通过它访问右值。

主要的用法在于移动语义，，即移动构造和移动赋值函数。构造函数形参设置成右值引用，传进来的对象成为右值，要初始化的对象将它的内存空间“偷”过来（它的指针地址赋给该对象，再将它的指针置空），这样一来，就避免了申请新的空间以及释放右值对象的空间，这一招“借尸还魂”可以有效地提高效率。

C/C++内存分配

C/C++程序内存布局
 C 程序内存布局

堆与栈

① 管理方式：栈由编译器管理，堆由程序员自己申请和释放；
② 大小限制：程序栈大小一般固定较小（几M），堆较大（几G）;
③ 分配方式：堆动态分配，栈一般是静态分配（如局部变量的定义）也有动态分配（不常用）
④ 生长方向：从上图可看出，栈向低地址端扩展；堆向高地址端扩展；
⑤ 分配效率：栈由系统提供，甚至有专门的寄存器和指令负责，而堆有C++程序库实现，有复杂的堆算法，故栈效率要高于堆；
⑥ 此外，堆的分配还会产生内碎片，影响存储内存的使用，栈先进后出结构，不会产生碎片。

C++的访问控制

public：类内、类对象、友元内
protected：类内、友元内
private：类内、友元内

发生继承时：
public：基类private不可访问，public成为public，protect成为private；
protected：基类private不可访问，public成为protected，protected还是protected;
private：基类private不可访问，public和protected都成为private;

C/C++编程输入输出相关函数

二、STL容器和算法

STL allocator 的实现

STL空间配置器，SGI的是实现形式是std::alloc，所有的容器都实际使用alloc作为空间配置器，不接受反驳（这里的空间不只是内存还有外存，如磁盘）。alloc并不符合标准，他也实现了一个符合部分标准的std::allocate配置器，但只是对new和delete做了简单封装，效率太低，它自己都没用过。

一般的，我们使用new和delete运算符配置对象。新建对象涉及两个步骤：①使用：：operator new 配置内存，②用构造函数构造对象内容；销毁对象也涉及两步骤：①使用析构函数析构函数内容；②使用：：operator delete 释放内存。

SGI的实现则是：内存配置使用alloc:allocate()，对象构造使用::construct()；对象析构使用::destroy()，内存释放使用alloc:deallocate()。

为什么要实现alloc? 怎么实现的？
级配置器将128bytes下空间分成16个等级来分配空间，显著的减少了内部碎片，提高了内存的使用效率。

下图中第二级忘记画内存块的回收了，是存在回收的！
在这里插入图片描述

参考：C++ 基础知识汇总l

map/unordered_map和set/unordered_set的区别

map/unordered_map的区别：unordered_map可类比于Python中的字典。其实现使用了哈希表，可以以O(1)的时间复杂度访问到对应元素，但缺点是有较高的额外空间复杂度。与之对应，STL中的map对应的数据结构是红黑树，红黑树内的数据时有序的，在红黑树上查找的时间复杂度是O(logN)，相对于unordered_map的查询速度有所下降，但额外空间开销减小。
结论：如果需要内部元素自动排序，使用map，不需要排序使用unordered_map
set/unordered_set：set作为一个容器也是用来存储同一数据类型的数据类型，并且能从一个数据集合中取出数据，在set中每个元素的值都唯一，而且系统能根据元素的值自动进行排序，set的元素不像map那样可以同时拥有实值(value)和键值(key)，set元素的键值就是实值。set不允许两个元素有相同的键值。

set与map、unordered_map、unordered_set与哈希表

map 和 set 区别在于：

map 中的元素是 key-value（关键字—值）对：关键字起到索引的作用，值则表示与索引相关联的数据；set 与之相对就是关键字的简单集合，set 中每个元素只包含一个关键字key。
set 的迭代器是 const 的，不允许修改元素的值；map 允许修改 value，但不允许修改 key。其原因是因为map 和 set 是根据关键字排序来保证其有序性的。
对于set，如果允许修改 key 的话，那么首先需要删除该键，然后调节平衡，再插入修改后的键值，调节平衡，如此一来，严重破坏了 map 和 set 的结构，导致 iterator 失效，不知道应该指向改变前的位置，还是指向改变后的位置。所以 STL 中将 set 的迭代器设置成 const，不允许修改迭代器的值；
对于map，map 的迭代器则不允许修改 key 值，允许修改 value 值。
map 支持下标操作，set 不支持下标操作。map 可以用 key 做下标，map 的下标运算符[ ]将关键码作为下标去执行查找，如果关键码不存在，则插入一个具有该关键码和 mapped_type 类型默认值的元素至 map 中，因此下标运算符[ ]在 map 应用中需要慎用，const_map 不能用，只希望确定某一个关键值是否存在而不希望插入元素时也不应该使用，mapped_type 类型没有默认值也不应该使用。如果 find 能解决需要，尽可能用 find。

STL 基本组成及关系

参考答案：

STL 主要由：以下六部分组成：
①容器 ② 迭代器 ③ 仿函数 ④ 算法 ⑤ 分配器 ⑥ 配接器

他们之间的关系：
分配器：给容器分配存储空间。
算法：通过迭代器获取容器中的内容。
仿函数：可以协助算法完成各种操作。
配接器：用来套接适配仿函数。

vector和list的区别

概念：

1）Vector
连续存储的容器，动态数组，在堆上分配空间。
底层实现：数组

两倍容量增长：
vector 增加（插入）新元素时，如果未超过当时的容量，则还有剩余空间，那么直接添加到最后（插入指定位置），然后调整迭代器。如果没有剩余空间了，则会重新配置原有元素个数的两倍空间，然后将原空间元素通过复制的方式初始化新空间，再向新空间增加元素，最后析构并释放原空间，之前的迭代器会失效。

性能

访问：O(1)
插入：在最后插入（空间够）：很快
在最后插入（空间不够）：需要内存申请和释放，以及对之前数据进行拷贝。
在中间插入（空间够）：内存拷贝
在中间插入（空间不够）：需要内存申请和释放，以及对之前数据进行拷贝。
删除：在最后删除：很快
在中间删除：内存拷贝

适用场景：经常随机访问，且不经常对非尾节点进行插入删除。

2）List
动态链表，在堆上分配空间，每插入一个元数都会分配空间，每删除一个元素都会释放空间。
底层：双向链表

性能
访问：随机访问性能很差，只能快速访问头尾节点。
插入：很快，一般是常数开销
删除：很快，一般是常数开销

适用场景：经常插入删除大量数据

区别：

1）vector 底层实现是数组；list 是双向链表。
2）vector 支持随机访问，list 不支持。
3）vector 是顺序内存，list 不是。
4）vector 在中间节点进行插入删除会导致内存拷贝，list 不会。
5）vector 一次性分配好内存，不够时才进行 2 倍扩容；list 每次插入新节点都会进行内存申请。
6）vector 随机访问性能好，插入删除性能差；list 随机访问性能差，插入删除性能好。

应用

vector 拥有一段连续的内存空间，因此支持随机访问，如果需要高效的随即访问，而不在乎插入和删除的效率，使用 vector。

list 拥有一段不连续的内存空间，如果需要高效的插入和删除，而不关心随机访问，则应使用 list。

STL迭代器与指针的区别？迭代器如何删除元素？

迭代器是STL的关键所在，STL中心思想是把容器和算法分离开发，独立设计成泛型（类模板和函数模板），再用一种粘合剂将二者结合起来，迭代器就是该角色。迭代器按照容器内部次序访问元素，而避免了暴露/考虑容器内不得结构。毕竟容器内部的实现各异，map/set族使用RB-tree，unordered族使用hashtable，vector使用内置数组，通过三个核心指针实现，queue和list使用双端队列deque实现。

举个栗子：map的第一个元素是mostleft，最左节点，而vector第一个就是vec[0]使用指针必须要了解各个容器内部的实现，使用迭代器map.begin()/end(), vec.begin()/end()即可。