说明：

• 面试题来源于网络书籍，公司题目以及博主原创或修改（题目大部分来源于各种公司）；
• 文中很多题目，或许大家直接编译器写完，1分钟就出结果了。但在这里博主希望每一个题目，大家都要经过认真思考，答案不重要，重要的是通过题目理解所考知识点，好应对题目更多的变化；
• 博主与大家一起学习，一起刷题，共同进步；
• 写文不易，麻烦给个三连！！！

1.auto、decltype和decltype(auto)的用法

答案：

（1）auto
C++11新标准引入了auto类型说明符，用它就能让编译器替我们去分析表达式所属的类型。和原来那些只对应某种特定的类型说明符(例如 int)不同。
auto 让编译器通过初始值来进行类型推演。从而获得定义变量的类型，所以说 auto 定义的变量必须有初始值。

//普通；类型
int a = 1, b = 3;
auto c = a + b;// c为int型//const类型
const int i = 5;
auto j = i; // 变量i是顶层const, 会被忽略, 所以j的类型是int
auto k = &i; // 变量i是一个常量, 对常量取地址是一种底层const, 所以k的类型是const int*
const auto l = i; //如果希望推断出的类型是顶层const的, 那么就需要在auto前面加上cosnt//引用和指针类型
int x = 2;
int& y = x;
auto z = y; //z是int型不是int& 型
auto& p1 = y; //p1是int&型
auto p2 = &x; //p2是指针类型int*

（2）decltype
有的时候我们还会遇到这种情况，**我们希望从表达式中推断出要定义变量的类型，但却不想用表达式的值去初始化变量。**还有可能是函数的返回类型为某表达式的值类型。在这些时候auto显得就无力了，所以C++11又引入了第二种类型说明符decltype，它的作用是选择并返回操作数的数据类型。在此过程中，编译器只是分析表达式并得到它的类型，却不进行实际的计算表达式的值。

int func() {return 0};//普通类型
decltype(func()) sum = 5; // sum的类型是函数func()的返回值的类型int, 但是这时不会实际调用函数func()
int a = 0;
decltype(a) b = 4; // a的类型是int, 所以b的类型也是int//不论是顶层const还是底层const, decltype都会保留   
const int c = 3;
decltype(c) d = c; // d的类型和c是一样的, 都是顶层const
int e = 4;
const int* f = &e; // f是底层const
decltype(f) g = f; // g也是底层const//引用与指针类型
//1. 如果表达式是引用类型, 那么decltype的类型也是引用
const int i = 3, &j = i;
decltype(j) k = 5; // k的类型是 const int&//2. 如果表达式是引用类型, 但是想要得到这个引用所指向的类型, 需要修改表达式:
int i = 3, &r = i;
decltype(r + 0) t = 5; // 此时是int类型//3. 对指针的解引用操作返回的是引用类型
int i = 3, j = 6, *p = &i;
decltype(*p) c = j; // c是int&类型, c和j绑定在一起//4. 如果一个表达式的类型不是引用, 但是我们需要推断出引用, 那么可以加上一对括号, 就变成了引用类型了
int i = 3;
decltype((i)) j = i; // 此时j的类型是int&类型, j和i绑定在了一起

（3）decltype(auto)
decltype(auto)是C++14新增的类型指示符，可以用来声明变量以及指示函数返回类型。在使用时，会将“=”号右边的表达式替换掉auto，再根据decltype的语法规则来确定类型。举个例子：

int e = 4;
const int* f = &e; // f是底层const
decltype(auto) j = f;//j的类型是const int* 并且指向的是e

2.C++中的左值和右值怎么区分？

答案：

1. 普通类型的变量，因为有名字，可以取地址，都认为是左值
2. const修饰的常量，不可修改，只读类型的，理论应该按照右值对待，但因为其可以取地址(如果只是const类型常量的定义，编译器不给其开辟空间，如果对该常量取地址时，编译器才为其开辟空间)，C++11认为其是左值。
3. 如果表达式的运行结果是一个临时变量或者对象，认为是右值。
4. 如果表达式运行结果或单个变量是一个引用则认为是左值。

总结：
1.不能简单地通过能否放在=左侧右侧或者取地址来判断左值或者右值，要根据表达式结果或变量的性质判断。
2.能得到引用的表达式一定能够作为引用，否则就用常引用。

3.引用与右值引用比较

答案：
在C++98中的普通引用与const引用在引用实体上的区别：

int main()
{// 普通类型引用只能引用左值，不能引用右值int a = 10;int& ra1 = a; // ra为a的别名//int& ra2 = 10; // 编译失败，因为10是右值const int& ra3 = 10;const int& ra4 = a;return 0;
}

注意： 普通引用只能引用左值，不能引用右值，const引用既可引用左值，也可引用右值。
C++11中右值引用：只能引用右值，一般情况不能直接引用左值。

int main()
{// 10纯右值，本来只是一个符号，没有具体的空间，// 右值引用变量r1在定义过程中，编译器产生了一个临时变量，r1实际引用的是临时变量int&& r1 = 10;r1 = 100;int a = 10;int&& r2 = a; // 编译失败：右值引用不能引用左值return 0;
}

4.C++移动语义是什么，有什么好处，怎么使用？

答案：
C++移动语义是一种用于在对象之间转移资源所有权的机制。它通过将资源的所有权从一个对象转移到另一个对象，避免了不必要的资源拷贝和内存分配，提高了程序的性能和效率。
移动语义的好处包括：

• 减少资源拷贝：传统的拷贝操作需要复制对象的所有成员变量，包括动态分配的内存等。而移动语义只是将资源的所有权转移，避免了不必要的拷贝操作，提高了性能。
• 避免内存分配：在移动语义中，可以将一个对象的资源直接转移到另一个对象，而不需要进行额外的内存分配和释放操作，减少了内存的开销。
• 支持大对象的高效传递：对于大对象，传统的拷贝操作可能会导致性能下降。而移动语义可以避免不必要的拷贝，提高了大对象的传递效率。

使用移动语义需要使用特殊的语法和语义：

• 移动构造函数：通过定义移动构造函数，可以将一个对象的资源转移到另一个对象，而不是进行拷贝。移动构造函数使用右值引用作为参数，并将资源的所有权从参数对象转移到正在构造的对象。
• 移动赋值运算符：类似于移动构造函数，移动赋值运算符用于将一个对象的资源转移到另一个对象。它使用右值引用作为参数，并将资源的所有权从参数对象转移到当前对象。

#include <iostream>
#include <string>class MyString {
public:MyString() : data(nullptr), size(0) {}// 移动构造函数MyString(MyString&& other) noexcept {data = other.data;size = other.size;other.data = nullptr;other.size = 0;}// 移动赋值运算符MyString& operator=(MyString&& other) noexcept {if (this != &other) {delete[] data;data = other.data;size = other.size;other.data = nullptr;other.size = 0;}return *this;}// 析构函数~MyString() {delete[] data;}// 设置字符串void SetString(const char* str) {size = strlen(str);data = new char[size + 1];strcpy(data, str);}// 打印字符串void PrintString() {std::cout << data << std::endl;}private:char* data;int size;
};int main() {MyString str1;str1.SetString("Hello");MyString str2 = std::move(str1);  // 使用移动构造函数将资源从str1移动到str2str1.PrintString();  // 输出为空，str1的资源已经被移动str2.PrintString();  // 输出 "Hello"MyString str3;str3 = std::move(str2);  // 使用移动赋值运算符将资源从str2移动到str3str2.PrintString();  // 输出为空，str2的资源已经被移动str3.PrintString();  // 输出 "Hello"return 0;
}

5.右值引用引用左值

答案：
按照语法，右值引用只能引用右值，但右值引用一定不能引用左值吗？因为：有些场景下，可能真的需要用右值去引用左值实现移动语义。
当需要用右值引用引用一个左值时，可以通过move函数将左值转化为右值。C++11中，std::move()函数位于 头文件中，该函数名字具有迷惑性，它并不搬移任何东西，唯一的功能就是将一个左值强制转化为右值引用，然后实现移动语义。

template<class _Ty>
inline typename remove_reference<_Ty>::type&& move(_Ty&& _Arg) _NOEXCEPT
{// forward _Arg as movablereturn ((typename remove_reference<_Ty>::type&&)_Arg);
}

注意：

1. 被转化的左值，其生命周期并没有随着左值的转化而改变，即std::move转化的左值变量lvalue不会被销毁。
2. STL中也有另一个move函数，就是将一个范围中的元素搬移到另一个位置。

int main()
{String s1("hello world");String s2(move(s1));String s3(s2);return 0;
}

注意：以上代码是move函数的经典的误用，因为move将s1转化为右值后，在实现s2的拷贝时就会使用移动构造，此时s1的资源就被转移到s2中，s1就成为了无效的字符串。

使用move的一个例子：

class Person
{
public:Person(char* name, char* sex, int age): _name(name), _sex(sex), _age(age){}Person(const Person& p): _name(p._name), _sex(p._sex), _age(p._age){}#if 0Person(Person&& p): _name(p._name), _sex(p._sex), _age(p._age){}#elsePerson(Person&& p): _name(move(p._name)), _sex(move(p._sex)), _age(p._age){}#endifprivate:string _name;string _sex;int _age;
};
Person GetTempPerson()
{Person p("prety", "male", 18);return p;
}
int main()
{Person p(GetTempPerson());return 0;
}

6.完美转发是什么东东？

答案：
完美转发是指在函数模板中，完全依照模板的参数的类型，将参数传递给函数模板中调用的另外一个函数。
所谓完美：函数模板在向其他函数传递自身形参时，如果相应实参是左值，它就应该被转发为左值；如果相应实参是右值，它就应该被转发为右值。这样做是为了保留在其他函数针对转发而来的参数的左右值属性进行不同处理（比如参数为左值时实施拷贝语义；参数为右值时实施移动语义）。

C++11通过forward函数来实现完美转发, 比如：

void Fun(int &x){cout << "lvalue ref" << endl;}
void Fun(int &&x){cout << "rvalue ref" << endl;}
void Fun(const int &x){cout << "const lvalue ref" << endl;}
void Fun(const int &&x){cout << "const rvalue ref" << endl;}template<typename T>
void PerfectForward(T &&t){Fun(std::forward<T>(t));
}int main()
{PerfectForward(10); // rvalue refint a;PerfectForward(a); // lvalue refPerfectForward(std::move(a)); // rvalue refconst int b = 8;PerfectForward(b); // const lvalue refPerfectForward(std::move(b)); // const rvalue refreturn 0;
}

7.lambda表达式中的捕获列表都有什么参数，含义如何

答案：
在C++11及以后的版本中，lambda表达式中的捕获列表是由0个或多个“捕捉项”组成，并以逗号分隔。捕捉列表主要有以下几种形式：

1. [=] 表示值传递方式捕捉所有局部变量。
2. [&] 表示引用传递方式捕捉所有局部变量。
3. [x] 表示值传递方式捕捉名为x的局部变量。
4. [&x] 表示引用传递方式捕捉名为x的局部变量。
5. [=, &x] 表示值传递方式捕捉所有局部变量，但以引用传递方式捕捉名为x的局部变量。
6. [&, x] 表示引用传递方式捕捉所有局部变量，但以值传递方式捕捉名为x的局部变量。
7. [&, &x] 表示引用传递方式捕捉所有局部变量，且以引用传递方式捕捉名为x的局部变量。

捕获列表可以理解为参数的一种类型，它可以起到传递外部数据的作用。根据传递的行为，捕获列表可以分为值捕获和引用捕获两种类型。值捕获与参数传值类似，被捕获的变量在lambda表达式被创建时拷贝，而非调用时才拷贝。

8.C++中NULL和nullptr区别

答案：
算是为了与C语言进行兼容而定义的一个问题吧。
NULL来自C语言，一般由宏定义实现，而 nullptr 则是C++11的新增关键字。
在C语言中，NULL被定义为(void*)0,而在C++语言中，NULL则被定义为整数0。编译器一般对其实际定义如下：

#ifdef __cplusplus
#define NULL 0
#else
#define NULL ((void *)0)
#endif

在C++中指针必须有明确的类型定义。但是将NULL定义为0带来的另一个问题是无法与整数的0区分。因为C++中允许有函数重载，所以可以试想如下函数定义情况：

#include <iostream>
using namespace std;void fun(char* p) {cout << "char*" << endl;
}void fun(int p) {cout << "int" << endl;
}int main()
{fun(NULL);return 0;
}
//输出结果：int

那么在传入NULL参数时，会把NULL当做整数0来看，如果我们想调用参数是指针的函数，该怎么办呢?。nullptr在C++11被引入用于解决这一问题，nullptr可以明确区分整型和指针类型，能够根据环境自动转换成相应的指针类型，但不会被转换为任何整型，所以不会造成参数传递错误。
nullptr的一种实现方式如下：

const class nullptr_t{
public:template<class T>  inline operator T*() const{ return 0; }template<class C, class T> inline operator T C::*() const { return 0; }
private:void operator&() const;
} nullptr = {};

以上通过模板类和运算符重载的方式来对不同类型的指针进行实例化从而解决了(void*)指针带来参数类型不明的问题，**另外由于nullptr是明确的指针类型，所以不会与整形变量相混淆。**但nullptr仍然存在一定问题，例如：

#include <iostream>
using namespace std;void fun(char* p)
{cout<< "char* p" <<endl;
}
void fun(int* p)
{cout<< "int* p" <<endl;
}void fun(int p)
{cout<< "int p" <<endl;
}
int main()
{fun((char*)nullptr);//语句1fun(nullptr);//语句2fun(NULL);//语句3return 0;
}
//运行结果：
//语句1：char* p
//语句2:报错，有多个匹配
//3：int p

在这种情况下存在对不同指针类型的函数重载，此时如果传入nullptr指针则仍然存在无法区分应实际调用哪个函数，这种情况下必须显示的指明参数类型。

9.智能指针的原理、常用的智能指针及实现

答案：
(1) shared_ptr
实现原理：采用引用计数器的方法，允许多个智能指针指向同一个对象，每当多一个指针指向该对象时，指向该对象的所有智能指针内部的引用计数加1，每当减少一个智能指针指向对象时，引用计数会减1，当计数为0的时候会自动的释放动态分配的资源。

• 智能指针将一个计数器与类指向的对象相关联，引用计数器跟踪共有多少个类对象共享同一指针
• 每次创建类的新对象时，初始化指针并将引用计数置为1
• 当对象作为另一对象的副本而创建时，拷贝构造函数拷贝指针并增加与之相应的引用计数
• 对一个对象进行赋值时，赋值操作符减少左操作数所指对象的引用计数（如果引用计数为减至0，则删除对象），并增加右操作数所指对象的引用计数
• 调用析构函数时，构造函数减少引用计数（如果引用计数减至0，则删除基础对象）

(2) unique_ptr
unique_ptr采用的是独享所有权语义，一个非空的unique_ptr总是拥有它所指向的资源。转移一个unique_ptr将会把所有权全部从源指针转移给目标指针，源指针被置空；所以unique_ptr不支持普通的拷贝和赋值操作，不能用在STL标准容器中；局部变量的返回值除外（因为编译器知道要返回的对象将要被销毁）；如果你拷贝一个unique_ptr，那么拷贝结束后，这两个unique_ptr都会指向相同的资源，造成在结束时对同一内存指针多次释放而导致程序崩溃。

(3) weak_ptr
weak_ptr：弱引用。 引用计数有一个问题就是互相引用形成环（环形引用），这样两个指针指向的内存都无法释放。需要使用weak_ptr打破环形引用。weak_ptr是一个弱引用，它是为了配合shared_ptr而引入的一种智能指针，它指向一个由shared_ptr管理的对象而不影响所指对象的生命周期，也就是说，它只引用，不计数。如果一块内存被shared_ptr和weak_ptr同时引用，当所有shared_ptr析构了之后，不管还有没有weak_ptr引用该内存，内存也会被释放。所以weak_ptr不保证它指向的内存一定是有效的，在使用之前使用函数lock()检查weak_ptr是否为空指针。

(4) auto_ptr
主要是为了解决“有异常抛出时发生内存泄漏”的问题 。因为发生异常而无法正常释放内存。
auto_ptr有拷贝语义，拷贝后源对象变得无效，这可能引发很严重的问题；而unique_ptr则无拷贝语义，但提供了移动语义，这样的错误不再可能发生，因为很明显必须使用std::move()进行转移。
auto_ptr不支持拷贝和赋值操作，不能用在STL标准容器中。STL容器中的元素经常要支持拷贝、赋值操作，在这过程中auto_ptr会传递所有权，所以不能在STL中使用。

智能指针shared_ptr代码实现：

template<typename T>
class SharedPtr
{
public:SharedPtr(T* ptr = NULL):_ptr(ptr), _pcount(new int(1)){}SharedPtr(const SharedPtr& s):_ptr(s._ptr), _pcount(s._pcount){(*_pcount)++;}SharedPtr<T>& operator=(const SharedPtr& s){if (this != &s){if (--(*(this->_pcount)) == 0){delete this->_ptr;delete this->_pcount;}_ptr = s._ptr;_pcount = s._pcount;(*_pcount)++;}return *this;}T& operator*(){return *(this->_ptr);}T* operator->(){return this->_ptr;}~SharedPtr(){--(*(this->_pcount));if (*(this->_pcount) == 0){delete _ptr;_ptr = NULL;delete _pcount;_pcount = NULL;}}
private:T* _ptr;int* _pcount;//指向引用计数的指针
};

10.智能指针的作用

答案：

1. C++11中引入了智能指针的概念，方便管理堆内存。使用普通指针，容易造成堆内存泄露（忘记释放），二次释放，程序发生异常时内存泄露等问题等，使用智能指针能更好的管理堆内存。
2. 智能指针在C++11版本之后提供，包含在头文件中，shared_ptr、unique_ptr、weak_ptr。shared_ptr多个指针指向相同的对象。shared_ptr使用引用计数，每一个shared_ptr的拷贝都指向相同的内存。每使用他一次，内部的引用计数加1，每析构一次，内部的引用计数减1，减为0时，自动删除所指向的堆内存。shared_ptr内部的引用计数是线程安全的，但是对象的读取需要加锁。
3. 初始化。智能指针是个模板类，可以指定类型，传入指针通过构造函数初始化。也可以使用make_shared函数初始化。不能将指针直接赋值给一个智能指针，一个是类，一个是指针。例如std::shared_ptr p4 = new int(1);的写法是错误的。拷贝和赋值。拷贝使得对象的引用计数增加1，赋值使得原对象引用计数减1，当计数为0时，自动释放内存。后来指向的对象引用计数加1，指向后来的对象.
4. unique_ptr“唯一”拥有其所指对象，同一时刻只能有一个unique_ptr指向给定对象（通过禁止拷贝语义、只有移动语义来实现）。相比与原始指针unique_ptr用于其RAII的特性，使得在出现异常的情况下，动态资源能得到释放。unique_ptr指针本身的生命周期：从unique_ptr指针创建时开始，直到离开作用域。离开作用域时，若其指向对象，则将其所指对象销毁(默认使用delete操作符，用户可指定其他操作)。unique_ptr指针与其所指对象的关系：在智能指针生命周期内，可以改变智能指针所指对象，如创建智能指针时通过构造函数指定、通过reset方法重新指定、通过release方法释放所有权、通过移动语义转移所有权。
5. 智能指针类将一个计数器与类指向的对象相关联，引用计数跟踪该类有多少个对象共享同一指针。每次创建类的新对象时，初始化指针并将引用计数置为1；当对象作为另一对象的副本而创建时，拷贝构造函数拷贝指针并增加与之相应的引用计数；对一个对象进行赋值时，赋值操作符减少左操作数所指对象的引用计数（如果引用计数为减至0，则删除对象），并增加右操作数所指对象的引用计数；调用析构函数时，构造函数减少引用计数（如果引用计数减至0，则删除基础对象）。
6. weak_ptr 是一种不控制对象生命周期的智能指针, 它指向一个 shared_ptr 管理的对象. 进行该对象的内存管理的是那个强引用的 shared_ptr. weak_ptr只是提供了对管理对象的一个访问手段。weak_ptr 设计的目的是为配合 shared_ptr 而引入的一种智能指针来协助 shared_ptr 工作, 它只可以从一个 shared_ptr 或另一个 weak_ptr 对象构造, 它的构造和析构不会引起引用记数的增加或减少。