我总结的一些 C++ 高频面试题（收藏）
extern “C”
extern 是C/C++ 语言中表明函数和全局变量作用范围的关键字，该关键字告诉编译器，其声明的函数和变量可以在本模块或其它模块中使用。
被extern "C" 修饰的变量和函数是按照C语言方式编译和连接的。
extern “C” 这个声明的真实目的:解决名字匹配问题，实现C++与C的混合编程。
const 修饰指针的三种效果
const int*p=&a；
当把 const 放最前面的时候，它修饰的就是 *p，那么 p 就不可变。p 表示的是指针变量 p 所指向的内存单元里面的内容，此时这个内容不可变。其他的都可变，如 p 中存放的是指向的内存单元的地址，这个地址可变，即 p 的指向可变。但指向谁，谁的内容就不可变。
int*const p=&a；
此时 const 修饰的是 p，所以 p 中存放的内存单元的地址不可变，而内存单元中的内容可变。即 p 的指向不可变，p 所指向的内存单元的内容可变。
const int*const p=&a；
此时 *p 和 p 都被修饰了，那么 p 中存放的内存单元的地址和内存单元中的内容都不可变。
http://c.biancheng.net/view/218.html
c++ 指针和引用的区别
指针是一个变量，只不过这个变量存储的是一个地址，指向内存的一个存储单元；而引用跟原来的变量实质上是同一个东西，只不过是原变量的一个别名而已。
malloc/free 与 new/delete
如果用free释放“new创建的动态对象”，那么该对象因无法执行析构函数而可能导致程序出错。如果用delete释放“malloc申请的动态内存”，理论上讲程序不会出错，但是该程序的可读性很差。所以new/delete，malloc/free必须配对使用。
C++ 虚函数表
每个包含了虚函数的类都包含一个虚表。
一个类继承了包含虚函数的基类，那么这个类也拥有自己的虚表。
虚表是一个指针数组，其元素是虚函数的指针，每个元素对应一个虚函数的函数指针。
虚表是属于类的，而不是属于某个具体的对象，一个类只需要一个虚表即可。同一个类的所有对象都使用同一个虚表。
为了指定对象的虚表，对象内部包含一个虚表的指针，来指向自己所使用的虚表。
vector push_back 和 emplace_back 区别
区别主要是针对对象而言，emplace_back 可以减少一次拷贝构造函数的调用。
vector＜bool＞不是存储bool类型元素的容器
//创建一个 vector<bool> 容器
vector<bool>cont{0,1};
//试图将指针 p 指向 cont 容器中第一个元素
bool *p = &cont[0];
以上代码无法编译通过。
为了节省空间，vector底层在存储各个 bool 类型值时，每个 bool 值都只使用一个比特位（二进制位）来存储。也就是说在 vector底层，一个字节可以存储 8 个 bool 类型值。
deque 容器的存储结构
vector 容器采用连续的线性空间不同，deque 容器存储数据的空间是由一段一段等长的连续空间构成，各段空间之间并不一定是连续的，可以位于在内存的不同区域。
当 deque 容器需要在头部或尾部增加存储空间时，它会申请一段新的连续空间，同时在 map 数组的开头或结尾添加指向该空间的指针，由此该空间就串接到了 deque 容器的头部或尾部。
STL map 和 unordered_map 的区别
map 是一种有序的容器，底层是用红黑树实现的，它可以做到 O(logn) 时间完成查找、插入、删除元素的操作。
unordered_map是一种无序的容器，底层是用哈希表实现的(哈希表-维基百科)，哈希表最大的优点是把数据的查找和存储时间都大大降低。
C++ RVO Return Value Optimization
#include <stdio.h>struct Message
{Message(){ printf("Message::Message() is called\\n"); }Message(const Message &){printf("Message::Message(const Message &msg) is called\\n");}Message& operator=(const Message &){printf("Message::operator=(const Message &) is called\\n");}~Message(){printf("Message::~Message() is called\\n");}int a;int b;int c;int d;int e;int f;
};Message getMessage()
{Message result;result.a = 0x11111111;return result;
}int main()
{Message msg = getMessage();return 0;
}
你认为运行时会输出什么呢？是不是这样：
Message::Message() is called
Message::Message(const Message &msg) is called
Message::~Message() is called
Message::~Message() is called
RVO 优化之后：
Message::Message() is called
Message::~Message() is called
它存在的目的是优化掉不必要的拷贝构造函数的调用，基本手段是直接将返回的对象构造在调用者栈帧上。
STL unordered_map 原理
C++ STL 标准库中，不仅是 unordered_map 容器，所有无序容器的底层实现都采用的是哈希表存储结构。存储结构：数组+链表，数组用来保存链表的头指针，各个键值对存储在链表的结点中
当有新键值对存储到无序容器中时，整个存储过程分为如下几步：
将该键值对中键的值带入设计好的哈希函数，会得到一个哈希值（一个整数，用 H 表示）；
将 H 和无序容器拥有桶的数量 n 做整除运算（即 H % n），该结果即表示应将此键值对存储到的桶的编号；
建立一个新节点存储此键值对，同时将该节点链接到相应编号的桶上。
Android HIDL
AIDL常用于连接App和Framework，HIDL则是用来连接Framework和HAL，AIDL使用Binder通信，HIDL则使用HwBinder通信，他们都是通过Binder驱动完成通信，只不过两个Binder域不一样。
将 Framework 与 HAL 独立出来，简化Android系统升级的影响与难度。
app -> java framework -> jni -> hidl service -> HAL
Android Malloc Debug 原理
Malloc Debug 可用于检查内存泄漏、内存越界、double free、use after free
-
代理内存分配和释放；
-
额外申请一部分内存用于保存内存的信息（Header）和设置内存边界（guard）；
-
调用栈跟踪。
Android ASan 原理
主要是通过 shadow 内存，用于描述应用程序内存区域是否可被读写。
程序申请的内存的前后，各增加一个redzone区域（n * 8bytes），用户申请的内存对应的shadow内存会被标记成可读写的，而redzone区域内存对应的shadow内存则会被标记成不可读写的。
free对象时，asan不会立即把这个对象的内存释放掉，而是写入1个负数到该对象的shadown内存中，即将该对象成不可读写的状态。
并将它记录放到一个隔离区(book keeping)中, 这样当有野指针或use-after-free的情况时，就能跟进shadow内存的状态，发现程序的异常；一段时间后如果程序没有异常，就会再释放隔离区中的对象。
编译器在对每个变量的load/store操作指令前都插入检查代码，确认是否有overflow、underflow、use-after-free等问题。
C++ 仿函数
重载函数调用操作符的类，其对象常称为函数对象(function object)，也叫仿函数(functor)，使得类对象可以像函数那样调用。
函数对象通常不定义构造和析构函数，所以在构造和析构时不会发生任何问题，避免了函数调用时的运行时问题。
lambda 表达式的内部实现其实也是仿函数。
C++ 20 协程
协程就是一段可以挂起（suspend）和恢复（resume）的程序，一般而言，就是一个支持挂起和恢复的函数。
不阻塞当前执行的线程，把当前函数（协程）执行的位置存起来，在将来某个时间点又读取出来继续执行的。
C++ 智能指针
C++中智能指针的实现主要依赖于两个技术概念：
1、析构函数，对象被销毁时会被调用的一个函数，对于基于栈的对象而言，如果对象离开其作用域则对象会被自动销毁，而此时析构函数也自动会被调用。
2、引用计数技术，维护一个计数器用于追踪资源(如内存)的被引用数，当资源被引用时，计数器值加1，当资源被解引用时，计算器值减1。
3、操作符重载。
智能指针的大致实现原理就是在析构函数中，检查所引用对象的引用计数，如果引用计数为0，则真正释放该对象内存。
// asdfa.cpp : 定义控制台应用程序的入口点。
//#include "stdafx.h"
#include<iostream>
using namespace std;
//引用计数类
class counter
{
public:counter(){}counter(int parCount) :count(parCount){}void increaseCount() { count++; }void decreasCount(){ count--; }int getCount(){ return count; }
private:int count;
};//智能指针
template<class T>
class SmartPointer
{
public:explicit SmartPointer(T* pT) :mPtr(pT), pCounter(new counter(1)){}explicit SmartPointer():mPtr(NULL),pCounter(NULL){}~SmartPointer() //析构函数，在引用计数为0时，释放原指针内存{if (pCounter != NULL){pCounter->decreasCount();if (pCounter->getCount() == 0){delete pCounter;delete mPtr;pCounter = NULL; //将pCounter赋值为NULL,防止悬垂指针mPtr = NULL;cout << "delete original pointer" << endl;}}}SmartPointer(SmartPointer<T> &rh) //拷贝构造函数，引用加1{this->mPtr=rh.mPtr;this->pCounter = rh.pCounter;this->pCounter->increaseCount();}SmartPointer<T>& operator=(SmartPointer<T> &rh) //赋值操作符，引用加1{if (this->mPtr == rh.mPtr)return *this;this->mPtr = rh.mPtr;this->pCounter = rh.pCounter;this->pCounter->increaseCount();return *this;}T& operator*() //重载*操作符{return *mPtr;}T* operator->() //重载->操作符{return p;}T* get(){return mPtr;}
private:T* mPtr;counter* pCounter;
};
int _tmain(int argc, _TCHAR* argv[])
{SmartPointer<int> sp1(new int(10));SmartPointer<int> sp2 = sp1;SmartPointer<int> sp3;sp3 = sp2;return 0;
}
C++ lambda 表达式
实际上是一个函数对象，内部重载了函数调用操作符；
lambda 表达式就是一个函数（匿名函数），也就是一个没有函数名的函数。为什么不需要函数名呢，因为我们直接（一次性的）用它，嵌入式用的它，不需要其他地方调用它
lambda 表达式也叫闭包。闭就是封闭的意思（封闭就是其他地方都不调用它），包就是函数。
lambda 表达式其实就是一个函数对象，他内部创建了一个重载()操作符的类。
lambda 表达式的简单语法如下：capture -> return value { body }, 只有 [capture] 捕获列表和 { body } 函数体是必选的，其他可选。
C++ 右值引用
右值引用是C++11中引入的新特性 , 它实现了转移语义和精确传递。
它的主要目的有两个方面：
消除两个对象交互时不必要的对象拷贝，节省运算存储资源，提高效率。
能够更简洁明确地定义泛型函数。
右值引用就是必须绑定到右值的引用，他有着与左值引用完全相反的绑定特性，我们通过 && 来获得右值引用。
右值引用的基本语法type &&引用名 = 右值表达式；
右值有一个重要的性质——只能绑定到一个将要销毁的对象上。举个例子：
int &&rr = i; //错误，i是一个变量，变量都是左值
int &&rr1 = i *42; //正确，i*42是一个右值
右值引用和左值引用的区别:
左值可以寻址，而右值不可以。
左值可以被赋值，右值不可以被赋值，可以用来给左值赋值。
左值可变,右值不可变（仅对基础类型适用，用户自定义类型右值引用可以通过成员函数改变）。
C++ 11 constexpr
constexpr是C++11中新增的关键字，其语义是“常量表达式”，也就是在编译期可求值的表达式。最基础的常量表达式就是字面值或全局变量/函数的地址或sizeof等关键字返回的结果，而其它常量表达式都是由基础表达式通过各种确定的运算得到的。constexpr值可用于enum、switch、数组长度等场合。
constexpr所修饰的变量一定是编译期可求值的，所修饰的函数在其所有参数都是constexpr时，一定会返回constexpr。
constexpr int Inc(int i) {return i + 1;
}constexpr int a = Inc(1); // ok
constexpr int b = Inc(cin.get()); // !error
constexpr int c = a * 2 + 1; // ok
constexpr还能用于修饰类的构造函数，即保证如果提供给该构造函数的参数都是constexpr，那么产生的对象中的所有成员都会是constexpr，该对象也就是constexpr对象了，可用于各种只能使用constexpr的场合。注意，constexpr构造函数必须有一个空的函数体，即所有成员变量的初始化都放到初始化列表中。
struct A {constexpr A(int xx, int yy): x(xx), y(yy) {}int x, y;
};constexpr A a(1, 2);
enum {SIZE_X = a.x, SIZE_Y = a.y};
constexpr的好处：
是一种很强的约束，更好地保证程序的正确语义不被破坏。
编译器可以在编译期对constexpr的代码进行非常大的优化，比如将用到的constexpr表达式都直接替换成最终结果等。
相比宏来说，没有额外的开销，但更安全可靠
C++ .hpp
定义与实现都包含在同一文件，调用者只需要include该hpp文件即可。
非常适合用来编写公用的开源库。
不可包含全局对象和全局函数。
类之间不可循环调用。
不可使用静态成员。
C++ 完美转发
所谓的完美转发，是指std::forward会将输入的参数原封不动地传递到下一个函数中，这个“原封不动”指的是，如果输入的参数是左值，那么传递给下一个函数的参数的也是左值；如果输入的参数是右值，那么传递给下一个函数的参数的也是右值。
防止在参数传递的过程中，右值引用会变成左值引用，从而调用拷贝构造而不是移动构造。
无论左值引用类型的变量还是右值引用类型的变量，都是左值，因为它们有名字。
C++ 锁
std::recursive_mutex 嵌套锁/递归锁/重入锁
std::recursive_mutex 允许同一个线程对互斥量多次上锁（即递归上锁），来获得对互斥量对象的多层所有权，std::recursive_mutex 释放互斥量时需要调用与该锁层次深度相同次数的 unlock()，可理解为 lock() 次数和 unlock() 次数相同，除此之外，std::recursive_mutex 的特性和 std::mutex 大致相同。
std::timed_mutex、 recursive_timed_mutex
timed_mutex.try_lock_for(std::chrono::milliseconds(200)); //在指定的时限中获取到锁则返回 true , 否则返回 false
std::shared_timed_mutex 与 std::shared_lock（C++14）
C++14 通过 std::shared_timed_mutex 和 std::shared_lock 来实现读写锁，保证多个线程可以同时读，但是写线程必须独立运行，写操作不可以同时和读操作一起进行。
struct ThreadSafe {mutable std::shared_timed_mutex mutex_;int value_;ThreadSafe() {value_ = 0;}int get() const {std::shared_lock<std::shared_timed_mutex> loc(mutex_);return value_;}void increase() {std::unique_lock<std::shared_timed_mutex> lock(mutex_);value_ += 1;}
};
C++ 20 Concepts
用于约束模板函数和模板类的模板参数。
https://zhuanlan.zhihu.com/p/107610017
C++ 20 Ranges
ranges 可以省掉很多循环，包括多重循环，写出来的代码又简单，可读性又好。
vector<int> data{4, 3, 4, 1, 8, 0, 8};
vector<int> result = data | actions::sort | actions::unique;