C/C++语言

最新推荐文章于 2024-07-03 19:38:19 发布

Jerry-se

最新推荐文章于 2024-07-03 19:38:19 发布

阅读量524

点赞数

分类专栏： C/C++面试题文章标签： c++

本文链接：https://blog.csdn.net/u011115292/article/details/120084171

版权

C/C++面试题专栏收录该内容

1 篇文章 0 订阅

订阅专栏

C 和 C++ 的区别

指针和引用的区别

malloc 和 new，free 和 delete 的区别

unique_ptr 中 std::move() 作用

C 和 C++ 的区别

除了面向对象与面向过程这个回答之外，C 与 C++ 的真正区别在哪里？

这几年不管是社团实习工作面试都有被问到这个问题。但是「面向对象以及面向过程」这个回答似乎都不是最好或者最完善的答案。

所以这个问题根本没有简单的答案，选3个角度谈就能写3篇论文。简单说说几个常见的误区。

误区1：C++是面向对象的C？并不是。现代C++是至少四种编程范式的集合体（面向过程，面向对象，泛型编程和元编程，函数式编程等，实际可能不止4种）。说C++是面向对象语言，是一种很瞧不起C++的说法，因为面向对象仅仅是C++的多种范式之一。

误区2：C是面向过程语言？不能这么说。在面向对象方面，C语言提供的语法支持比较薄弱，但这不表示C是面向过程的语言。用C语言写面向对象程序不仅不弱，甚至会有一些优势。世界上有很多非常重要的、大量使用面向对象技术的软件是用纯C写的。例如Linux的图形界面GNOME。

误区3：C是C++的子集，C支持的语法C++都支持。不对。C++在最初设计时是基于C的，绝大多数语法都兼容。但是，在一些细节却重要的地方，二者差别非常大。例如，C语言的函数指针非常神奇：

int (*pfunc)();

看上去pfunc可以指向返回值为int，无参数的函数？并不是。实际上pfunc可以指向任意返回值为int的函数，无论参数是什么。而无参的情况必须写明参数为void：

int (*pfunc)(void);

C语言不必指定参数类型也可以引用函数，这一点让C语言具有很强的动态特性。而C++去除了这种设计，因为破坏了类型安全。同理，C语言常用的(void*)转换在C++中也在很大程度上摒弃了，理由也是类型不安全。哪个设计好哪个不好不重要。重要的是：C并不是C++的子集，C++也不是C的超集。它们在语法、设计理念、常用写法方面均有不同，到今天二者的差别越来越大。

误区4：C++比C功能多，所以C++运行比C慢一点。不对。虽然C++加入了很多很多功能，但由于绝大多数功能都是在编译器上做手脚，大多情况下仅影响编译速度，而不影响运行速度。而且泛型、元编程等技术用好了，能让C++的程序运行的更快。反而是C，由于大量使用不定类型的转换，损失的性能相当可观。

总之，C与C++的区别远不是一段话能够讲清楚。

指针和引用的区别

1) 指针是一个变量，只不过这个变量存储的是一个地址，指向内存的一个存储单元；而引用跟原来的变量实质上是同一个东西，只不过是原变量的一个别名而已。"sizeof引用"得到的是所指向的变量(对象)的大小，而"sizeof指针"得到的是指针本身的大小；

2) 引用必须被初始化，指针不必。

3) 引用初始化以后不能被改变，指针可以改变所指的对象。

4) 不存在指向空值的引用，但是存在指向空值的指针。

5) 引用的创建和销毁不会调用类的拷贝构造函数和析构函数。

6) 指针可以有多级，但是引用只能是一级（int **p；合法而 int &&a是不合法的）。

malloc 和 new，free 和 delete 的区别

1) new/delete是C++关键字，需要编译器支持。malloc/free是库函数，需要头文件支持。

2) 使用new操作符申请内存分配时无须指定内存块的大小，编译器会根据类型信息自行计算。而malloc则需要显式地指出所需内存的尺寸。

3) new操作符内存分配成功时，返回的是对象类型的指针，类型严格与对象匹配，无须进行类型转换，故new是符合类型安全性的操作符。而malloc内存分配成功则是返回void * ，需要通过强制类型转换将void*指针转换成我们需要的类型。

4) new内存分配失败时，会抛出bac_alloc异常。malloc分配内存失败时返回NULL。

5) new会先调用operator new函数，申请足够的内存（通常底层使用malloc实现）。然后调用类型的构造函数，初始化成员变量，最后返回自定义类型指针。delete先调用析构函数，然后调用operator delete函数释放内存（通常底层使用free实现）。malloc/free是库函数，只能动态的申请和释放内存，无法强制要求其做自定义类型对象构造和析构工作。

6) C++允许重载new/delete操作符，特别的，布局new的就不需要为对象分配内存，而是指定了一个地址作为内存起始区域，new在这段内存上为对象调用构造函数完成初始化工作，并返回此地址。而malloc不允许重载。

7) new操作符从自由存储区（free store）上为对象动态分配内存空间，而malloc函数从堆上动态分配内存。自由存储区是C++基于new操作符的一个抽象概念，凡是通过new操作符进行内存申请，该内存即为自由存储区。而堆是操作系统中的术语，是操作系统所维护的一块特殊内存，用于程序的内存动态分配，C语言使用malloc从堆上分配内存，使用free释放已分配的对应内存。自由存储区不等于堆，如上所述，布局new就可以不位于堆中。

PS:

在C++中，内存区分为5个区，分别是堆、栈、自由存储区、全局/静态存储区、常量存储区；

在C中，C内存区分为堆、栈、全局/静态存储区、常量存储区；

extern C 的作用

主要作用就是为了能够正确实现C++代码调用其他C语言代码。被extern "C"修饰的变量和函数是按照C语言方式进行编译和链接的。

由于C++支持函数重载，因此编译器编译函数的过程中会将函数的参数类型也加到编译后的代码中，而不仅仅是函数名；而C语言并不支持函数重载，因此编译C语言代码的函数时不会带上函数的参数类型，一般只包括函数名。这个功能十分有用处，因为在C++出现以前，很多代码都是C语言写的，而且很底层的库也是C语言写的，为了更好的支持原来的C代码和已经写好的C语言库，需要在C++中尽可能的支持C，而extern "C"就是其中的一个策略。

被extern "C"限定的函数或变量是extern类型的，extern是C/C++语言中表明函数和全局变量的作用范围的关键字，该关键字告诉编译器，其申明的函数和变量可以在本模块或其他模块中使用。

extern对应的关键字是static，static表明变量或者函数只能在本模块中使用，因此，被static修饰的变量或者函数不可能被extern C修饰。

常用的容器有哪些

顺序性容器

1) vector: 是一段连续的内存地址，基于数组实现，其提供了自动内存管理功能（采用了STL普遍的内存管理器allocator），可以动态改变对象长度，提供随机访问。在尾部添加和删除元素的时间是常数的，但在头部或中间就是线性时间。

2) list: 非连续的内存，基于链表实现，属于循环双向链表，目的是实现快速插入和删除，但是随即访问却是比较慢。

3) forward_list: 实现了单链表，不可反转。相比于list，forward_list更简单，更紧凑，但功能也更少。

4) deque: 双端队列（double-ended queue），支持随机访问，与vector类似，主要区别在于，从deque对象的开始位置插入和删除元素的时间也是常数的，所以若多数操作发生在序列的起始和结尾处，则应考虑使用deque。为实现在deque两端执行插入和删除操作的时间为常数时间这一目的，deque对象的设计比vector更为复杂，因此，尽管二者都提供对元素的随机访问和在序列中部执行线性时间的插入和删除操作，但vector容器执行这些操作时速度更快些。

5) queue: 是一个适配器类，先进先出。queue模板让底层类（默认是deque）展示典型的队列接口。queue模板的限制比deque更多，它不仅不允许随机访问队列元素，甚至不允许遍历队列。与队列相同，只能将元素添加到队尾、从队首删除元素、查看队首和队尾的值、检查元素数目和测试队列是否为空。

6) priority_queue: 是另一个适配器类，支持的操作与queue相同，但最高优先级元素总是第一个出列。两者之间的主要区别在于，在priority_queue中，最大的元素被移到队首。内部区别在于，默认的底层类是vector。可以修改用于确定哪个元素放到队首的比较方式，方法是提供一个可选的构造函数参数。

7) stack: 与queue相似，stack也是一个适配器类，它给底层类（默认情况下为vector）提供了典型的栈接口，后进先出。

关联容器: 主要有map和set。map是key-value形式的，set是单值。map和set只能存放唯一的key值，multimap和multiset可以存放多个相同的key值。底层都基于树型结构。

1) map/multimap: map容器提供一个键值对(key-value)容器，map与multimap差别仅仅在于multimap允许一个键对应多个值。对于迭代器来说，可以修改实值，而不能修改key。map会根据key自动排序。

2) set/multiset: set的含义是集合，它是一个有序的容器，里面的元素都是排序好的支持插入、删除、查找等操作，就像一个集合一样，所有的操作都是严格在logn时间内完成，效率非常高。set和multiset的区别是,set插入的元素不能相同，但是multiset可以相同，set默认是自动排序的，使用方法类似list。

volatile 关键字的作用

volatile指出变量是随时可能发生变化的，与volatile变量有关的运算，不要进行编译优化，以免出错，如在C语言中，volatile关键字可以用来提醒编译器它后面所定义的变量随时有可能改变，因此编译后的程序每次需要存储或读取这个变量的时候，都会直接从变量地址中读取数据。如果没有volatile关键字，则编译器可能优化读取和存储，可能暂时使用寄存器中的值，如果这个变量由别的程序更新了的话，将出现不一致的现象。

VC++ 在产生release版可执行码时会进行编译优化，加volatile关键字的变量有关的运算，将不进行编译优化。

一个定义为volatile的变量是说这变量可能会被意想不到地改变，这样，编译器就不会去假设这个变量的值了。精确地说就是，优化器在用到这个变量时必须每次都小心地重新读取这个变量的值，而不是使用保存在寄存器里的备份。下面是volatile变量的几个例子：

1) 并行设备的硬件寄存器（如：状态寄存器）

2) 一个中断服务子程序中会访问到的非自动变量(Non-automatic variables)

3) 多线程应用中被几个任务共享的变量回答不出这个问题的人是不会被雇佣的。

搞嵌入式的家伙们经常同硬件、中断、RTOS等等打交道，所有这些都要求用到volatile变量。不懂得volatile的内容将会带来灾难。

有哪几种强制类型转换以及使用场景

1. C风格强制类型转换，如

Type b = (Type)a;

2. C++风格强制类型转换，有static_cast、const_cast、reinterpret_cast和dynamic_cast四种。

static_cast: 比C风格的强制类型转换要安全很多，有很大程度上的类型安全检查。但结果可能会出错，而且编译器不会给出错误信息。有明显缺点的，那就是无法消除const和volatile属性。

const_cast: 去除掉const或volitale属性。不是用于去除变量的常量性，而是去除指向常量对象的指针或引用的常量性，其去除常量性的对象必须为指针或引用，并且const_cast不支持不同类型指针或引用之间的转换，比如说float*转换成int*是不允许的，相差的话只能差const或volatile属性。

reinterpret_cast: 意为“重新解释”，它是C++中最接近于C风格强制类型转换的一个关键字。它让程序员能够将一种对象类型转换为另一种，不管它们是否相关。可以先使用reinterpret_cast把一个指针转换成一个整数，再把该整数转换成原类型的指针，还可以得到原先的指针值。使用reinterpret_cast强制转换过程仅仅只是比特位的拷贝，和C风格极其相似，实际上reinterpret_cast的出现就是为了让编译器强制接受static_cast不允许的类型转换，因此使用的时候要谨而慎之。

dynamic_cast: 是运行时处理的，运行时会进行类型检查（这点和static_cast差异较大）。不能用于内置基本数据类型的强制转换，只能对指针或引用进行强制转换。如果转换成功的话返回的是指向类的指针或引用，转换失败的话则会返回nullptr。进行上行转换时，与static_cast的效果是完全一样的，进行下行转换时，dynamic_cast具有类型检查的功能，比static_cast更安全。而且dynamic_cast运行时的类型检查需要有运行时类型信息，这个信息是存储在类的虚表中的。

C++11 新特性

简单说一些常见的C++11的新特性。

1. nullptr: 空指针，用来替代NULL。

传统 C++ 会把 NULL、0 视为同一种东西，这取决于编译器如何定义 NULL，有些编译器会将 NULL 定义为 ((void*)0)，有些则会直接将其定义为 0。C++ 不允许直接将 void * 隐式转换到其他类型，但如果 NULL 被定义为 ((void*)0)，那么当编译char *ch = NULL;时，NULL 只好被定义为 0。而这依然会产生问题，将导致了 C++ 中重载特性会发生混乱，考虑：

void foo(char *);
void foo(int);

对于这两个函数来说，如果 NULL 又被定义为了 0 那么 foo(NULL); 这个语句将会去调用 foo(int)，从而导致代码违反直观。为了解决这个问题，C++11 引入了 nullptr 关键字，专门用来区分空指针、0。

nullptr 的类型为 nullptr_t，能够隐式的转换为任何指针或成员指针的类型，也能和他们进行相等或者不等的比较。当需要使用 NULL 时候，养成直接使用 nullptr的习惯。

在没有C++ 11的nullptr的时候，我们怎么解决避免这个问题呢？我们可以自己实现一个:

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

2. 类型推导: C++11 引入了 auto 和 decltype 这两个关键字实现了类型推导，让编译器来操心变量的类型。

auto 在很早以前就已经进入了 C++，但是他始终作为一个存储类型的指示符存在，与 register 并存。在传统 C++ 中，如果一个变量没有声明为 register 变量，将自动被视为一个 auto 变量。而随着 register 被弃用，对 auto 的语义变更也就非常自然了。

使用 auto 进行类型推导的一个最为常见而且显著的例子就是迭代器。在以前我们需要这样来书写一个迭代器：

for(vector<int>::const_iterator itr = vec.cbegin(); itr != vec.cend(); ++itr)

而有了 auto 之后可以：

for(auto itr = vec.cbegin(); itr != vec.cend(); ++itr);

decltype 关键字是为了解决 auto 关键字只能对变量进行类型推导的缺陷而出现的。它的用法和 sizeof 很相似：decltype(表达式)

auto x = 1;
auto y = 2;
decltype(x+y) z;

3. 基于范围的 for 循环

C++11 引入了基于范围的迭代写法，我们拥有了能够写出像 Python 一样简洁的循环语句。
最常用的 std::vector 遍历将从原来的样子：

for(std::vector<int>::iterator i = arr.begin(); i != arr.end(); ++i) {
    std::cout << *i << std::endl;
}

使用范围for循环变得非常的简单：

// & 启用了引用
for(auto &i : arr) {    
    std::cout << i << std::endl;
}

4. 初始化列表

C++11 提供了统一的语法来初始化任意的对象，例如：

struct A {
    int a;
    float b;
};
struct B {

    B(int _a, float _b): a(_a), b(_b) {}
private:
    int a;
    float b;
};

A a {1, 1.1};    // 统一的初始化语法
B b {2, 2.2};

5. Lambda 表达式

Lambda 表达式，实际上就是提供了一个类似匿名函数的特性，而匿名函数则是在需要一个函数，但是又不想费力去命名一个函数的情况下去使用的。基本语法如下：

[ caputrue ] ( params ) opt -> ret { body; };

1) capture是捕获列表；
2) params是参数表；(选填)
3) opt是函数选项；可以填mutable,exception,attribute（选填）
mutable说明lambda表达式体内的代码可以修改被捕获的变量，并且可以访问被捕获的对象的non-const方法。
exception说明lambda表达式是否抛出异常以及何种异常。
attribute用来声明属性。
4) ret是返回值类型（拖尾返回类型）。(选填)
5) body是函数体。

捕获列表：lambda表达式的捕获列表精细控制了lambda表达式能够访问的外部变量，以及如何访问这些变量。

1) []不捕获任何变量。
2) [&]捕获外部作用域中所有变量，并作为引用在函数体中使用（按引用捕获）。
3) [=]捕获外部作用域中所有变量，并作为副本在函数体中使用(按值捕获)。注意值捕获的前提是变量可以拷贝，且被捕获的变量在 lambda 表达式被创建时拷贝，而非调用时才拷贝。如果希望lambda表达式在调用时能即时访问外部变量，我们应当使用引用方式捕获。

int a = 0;
auto f = [=] { return a; };
a+=1;
cout << f() << endl;       //输出0

int a = 0;
auto f = [&a] { return a; };
a+=1;
cout << f() <<endl;       //输出1

4) [=,&foo]按值捕获外部作用域中所有变量，并按引用捕获foo变量。
5) [bar]按值捕获bar变量，同时不捕获其他变量。
6) [this]捕获当前类中的this指针，让lambda表达式拥有和当前类成员函数同样的访问权限。如果已经使用了&或者=，就默认添加此选项。捕获this的目的是可以在lamda中使用当前类的成员函数和成员变量。

class A
{
 public:
     int i_ = 0;

     void func(int x,int y){
         auto x1 = [] { return i_; };                   //error,没有捕获外部变量
         auto x2 = [=] { return i_ + x + y; };          //OK
         auto x3 = [&] { return i_ + x + y; };          //OK
         auto x4 = [this] { return i_; };               //OK
         auto x5 = [this] { return i_ + x + y; };       //error,没有捕获x,y
         auto x6 = [this, x, y] { return i_ + x + y; }; //OK
         auto x7 = [this] { return i_++; };             //OK
      }
};
int a=0 , b=1;
auto f1 = [] { return a; };                        //error,没有捕获外部变量    
auto f2 = [&] { return a++ };                      //OK
auto f3 = [=] { return a; };                       //OK
auto f4 = [=] {return a++; };                      //error,a是以复制方式捕获的，无法修改
auto f5 = [a] { return a+b; };                     //error,没有捕获变量b
auto f6 = [a, &b] { return a + (b++); };           //OK
auto f7 = [=, &b] { return a + (b++); };           //OK

注意f4，虽然按值捕获的变量值均复制一份存储在lambda表达式变量中，修改他们也并不会真正影响到外部，但我们却仍然无法修改它们。如果希望去修改按值捕获的外部变量，需要显示指明lambda表达式为mutable。被mutable修饰的lambda表达式就算没有参数也要写明参数列表。

原因：lambda表达式可以说是就地定义仿函数闭包的“语法糖”。它的捕获列表捕获住的任何外部变量，最终会变为闭包类型的成员变量。按照C++标准，lambda表达式的operator()默认是const的，一个const成员函数是无法修改成员变量的值的。而mutable的作用，就在于取消operator()的const。

int a = 0;
auto f1 = [=] { return a++; };                //error
auto f2 = [=] () mutable { return a++; };     //OK

lambda表达式的大致原理：每当你定义一个lambda表达式后，编译器会自动生成一个匿名类（这个类重载了()运算符），我们称为闭包类型（closure type）。那么在运行时，这个lambda表达式就会返回一个匿名的闭包实例，是一个右值。所以，我们上面的lambda表达式的结果就是一个个闭包。对于复制传值捕捉方式，类中会相应添加对应类型的非静态数据成员。在运行时，会用复制的值初始化这些成员变量，从而生成闭包。对于引用捕获方式，无论是否标记mutable，都可以在lambda表达式中修改捕获的值。至于闭包类中是否有对应成员，C++标准中给出的答案是：不清楚的，与具体实现有关。

6. 新增容器

std::array 保存在栈内存中，相比堆内存中的 std::vector，我们能够灵活的访问这里面的元素，从而获得更高的性能。std::array 会在编译时创建一个固定大小的数组，std::array 不能够被隐式的转换成指针，使用 std::array只需指定其类型和大小即可：

std::array<int, 4> arr= {1,2,3,4};
int len = 4;
std::array<int, len> arr = {1,2,3,4}; // 非法, 数组大小参数必须是常量表达式

std::forward_list 是一个列表容器，使用方法和 std::list 基本类似。
和 std::list 的双向链表的实现不同，std::forward_list 使用单向链表进行实现，提供了 O(1) 复杂度的元素插入，不支持快速随机访问（这也是链表的特点），也是标准库容器中唯一一个不提供 size() 方法的容器。当不需要双向迭代时，具有比 std::list 更高的空间利用率。

C++11 引入了两组无序容器：
std::unordered_map/std::unordered_multimap 和 std::unordered_set/std::unordered_multiset。

无序容器中的元素是不进行排序的，内部通过 Hash 表实现，插入和搜索元素的平均复杂度为 O(constant)。

元组 std::tuple
元组的使用有三个核心的函数：

std::make_tuple: 构造元组
std::get: 获得元组某个位置的值
std::tie: 元组拆包

#include <tuple>
#include <iostream>

auto get_student(int id)
{
    // 返回类型被推断为 std::tuple<double, char, std::string>
    if (id == 0)
        return std::make_tuple(3.8, 'A', "张三");
    if (id == 1)
        return std::make_tuple(2.9, 'C', "李四");
    if (id == 2)
        return std::make_tuple(1.7, 'D', "王五");
    return std::make_tuple(0.0, 'D', "null");   
    // 如果只写 0 会出现推断错误, 编译失败
}

int main()
{
    auto student = get_student(0);
    std::cout << "ID: 0, "
    << "GPA: " << std::get<0>(student) << ", "
    << "成绩: " << std::get<1>(student) << ", "
    << "姓名: " << std::get<2>(student) << '\n';

    double gpa;
    char grade;
    std::string name;

    // 元组进行拆包
    std::tie(gpa, grade, name) = get_student(1);
    std::cout << "ID: 1, "
    << "GPA: " << gpa << ", "
    << "成绩: " << grade << ", "
    << "姓名: " << name << '\n';
}

7. 正则表达式

正则表达式描述了一种字符串匹配的模式。一般使用正则表达式主要是实现下面三个需求：
1) 检查一个串是否包含某种形式的子串；
2) 将匹配的子串替换；
3) 从某个串中取出符合条件的子串。

C++11 提供的正则表达式库操作 std::string 对象，对模式 std::regex (本质是 std::basic_regex)进行初始化，通过 std::regex_match 进行匹配，从而产生 std::smatch （本质是 std::match_results 对象）。

8. 语言级线程支持

std::thread
std::mutex/std::unique_lock
std::future/std::packaged_task
std::condition_variable

代码编译需要使用 -pthread 选项

9. 右值引用和move语义

C++ 11引入了一种新的机制叫做“右值引用”，以便我们通过重载直接使用右值参数。我们所要做的就是写一个以右值引用为参数的构造函数：

string(string&& that)   // string&& is an rvalue reference to a string
{
  data = that.data;
  that.data = 0;
}

我们没有深度拷贝堆内存中的数据，而是仅仅复制了指针，并把源对象的指针置空。事实上，我们“偷取”了属于源对象的内存数据。由于源对象是一个右值，不会再被使用，因此客户并不会觉察到源对象被改变了。在这里，我们并没有真正的复制，所以我们把这个构造函数叫做“转移构造函数”（move constructor），他的工作就是把资源从一个对象转移到另一个对象，而不是复制他们。

对于C++ 11，编译器会依据参数是左值还是右值在复制构造函数和转移构造函数间进行选择。

如果是a=b，这样就会调用复制构造函数来初始化that（因为b是左值），赋值操作符会与新创建的对象交换数据，深度拷贝。这就是copy and swap 惯用法的定义：构造一个副本，与副本交换数据，并让副本在作用域内自动销毁。这里也一样。

如果是a = x + y，这样就会调用转移构造函数来初始化that（因为x+y是右值），所以这里没有深度拷贝，只有高效的数据转移。相对于参数，that依然是一个独立的对象，但是他的构造函数是无用的（trivial），因此堆中的数据没有必要复制，而仅仅是转移。没有必要复制他，因为x+y是右值，再次，从右值指向的对象中转移是没有问题的。

总结一下：复制构造函数执行的是深度拷贝，因为源对象本身必须不能被改变。而转移构造函数却可以复制指针，把源对象的指针置空，这种形式下，这是安全的，因为用户不可能再使用这个对象了。

右值引用是针对右值的新的引用类型，语法是X&&。以前的老的引用类型X& 现在被称作左值引用。使用右值引用X&&作为参数的最有用的函数之一就是转移构造函数X::X(X&& source)，它的主要作用是把源对象的本地资源转移给当前对象。

C++98标准库中提供了一种唯一拥有性的智能指针std::auto_ptr，该类型在C++11中已被废弃，因为其“复制”行为是危险的。C++ 11中，std::auto_ptr< T >已经被std::unique_ptr< T >所取代，后者就是利用的右值引用。其转移构造函数：

unique_ptr(unique_ptr&& source)   // note the rvalue reference
{
    ptr = source.ptr;
    source.ptr = nullptr;
}

这个转移构造函数跟auto_ptr中复制构造函数做的事情一样，但是它却只能接受右值作为参数。

unique_ptr<Shape> a(new Triangle);
unique_ptr<Shape> b(a);                 // error
unique_ptr<Shape> c(make_triangle());   // okay

第二行不能编译通过，因为a是左值，但是参数unique_ptr&& source只能接受右值，这正是我们所需要的，杜绝危险的隐式转移。第三行编译没有问题，因为make_triangle()是右值，转移构造函数会将临时对象的所有权转移给对象c，这正是我们需要的。

C++ 11在标准库的头文件< utility >中提供了一个模板函数std::move。实际上，std::move仅仅是简单地将左值转换为右值，它本身并没有转移任何东西。它仅仅是让对象可以转移。以下是如何正确的转移左值：

unique_ptr<Shape> a(new Triangle);
unique_ptr<Shape> b(a);              // still an error
unique_ptr<Shape> c(std::move(a));   // okay

请注意，第三行之后，a不再拥有Triangle对象。不过这没有关系，因为通过明确的写出std::move(a)，我们很清楚我们的意图：亲爱的转移构造函数，你可以对a做任何想要做的事情来初始化c；我不再需要a了，对于a，您请自便。

当然，如果你在使用了mova(a)之后，还继续使用a，那无疑是搬起石头砸自己的脚，还是会导致严重的运行错误。

总之，std::move(some_lvalue)将左值转换为右值（可以理解为一种类型转换），使接下来的转移成为可能。

10. 智能指针

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

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

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 返回内部对象(指针), 由于已经重载了()方法, 因此和直接使用对象是一样的

share_ptr虽然已经很好用了，但是有一点share_ptr智能指针还是有内存泄露的情况，当两个对象相互使用一个shared_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。

weak_ptr 没有重载*和->但可以使用 lock 获得一个可用的 shared_ptr 对象. 注意, weak_ptr 在使用前需要检查合法性.

expired 用于检测所管理的对象是否已经释放, 如果已经释放, 返回 true; 否则返回 false.

lock 用于获取所管理的对象的强引用(shared_ptr). 如果 expired 为 true, 返回一个空的 shared_ptr; 否则返回一个 shared_ptr, 其内部对象指向与 weak_ptr 相同.

use_count 返回与 shared_ptr 共享的对象的引用计数.

reset 将 weak_ptr 置空.

weak_ptr 支持拷贝或赋值, 但不会影响对应的 shared_ptr 内部对象的计数.

C++ 20 新特性

C++ 的三大特性

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

封装性：
把客观事物封装成抽象的类，并且类可以把自己的数据和方法只让可信的类或者对象操作，对不可信的进行信息隐藏。类将成员变量和成员函数封装在类的内部，根据需要设置访问权限，通过成员函数管理内部状态。

继承：

顾名思义，就像孩子会继承父母的一些性格或特点，两个类如果存在继承关系，其子类必定具有父类的相关属性（即变量）和方法（即函数）。继承的作用：避免公用代码的重复开发，减少代码和数据冗余。

多态：
C++中有两种多态，称为动多态（运行期多态）和静多态（编译期多态），而静多态主要通过模板来实现，宏也是实现静多态的一种途径。动多态在C++中是通过虚函数实现的，即在基类中存在一些接口（一般为纯虚函数），子类必须重载这些接口。这样通过使用基类的指针或者引用指向子类的对象，就可以实现调用子类对应的函数的功能。动多态的函数调用机制是执行期才能进行确定，所以它是动态的。

C++的多态实现原理

C++的多态性是通过迟绑定技术来实现的。

C++的多态性用一句话概括就是：在基类的函数前加上virtual关键字，在派生类中重写该函数，运行时将会根据对象的实际类型来调用相应的函数。如果对象类型是派生类，就调用派生类的函数；如果对象类型是基类，就调用基类的函数。

什么是虚函数

什么是纯虚函数

虚表指针的大小

虚函数表的存放内容

构造函数可以是虚函数吗

构造函数不需要是虚函数，也不允许是虚函数。

虚函数的调用需要 vptr 指针，而该指针存放在对象的内容空间中，需要调用构造函数才可以创建它的值，否则即使开辟了空间，该 vptr 指针为随机值；若构造函数声明为虚函数，那么由于对象还未创建，还没有内存空间，更没有 vptr 地址用来调用虚函数之一的构造函数了。

析构函数可以是虚函数吗

首先析构函数可以为虚函数，而且当要使用基类指针或引用调用子类时，最好将基类的析构函数声明为虚函数，否则可以存在内存泄露的问题。
举例说明：
子类B继承自基类A；A *p = new B; delete p;
　1）此时，如果类A的析构函数不是虚函数，那么delete p；将会仅仅调用A的析构函数，只释放了B对象中的A部分，而派生出的新的部分未释放掉。
2）如果类A的析构函数是虚函数，delete p; 将会先调用B的析构函数，再调用A的析构函数，释放B对象的所有空间。
补充： B *p = new B; delete p;时也是先调用B的析构函数，再调用A的析构函数。

一个空类会生成哪些函数

当空类Empty_one定义一个对象时Empty_one pt;sizeof(pt)仍是为1，但编译器会生成4个成员函数：一个缺省的构造函数、一个拷贝构造函数、一个析构函数、一个赋值运算符。这些函数只有在第一次使用它们的时候才会生成，他们都是inline并且public的。

class Empty  
{  
  public:  
    Empty();                            //缺省构造函数
    Empty(const Empty &rhs);            //拷贝构造函数
    ~Empty();                           //析构函数
    Empty& operator=(const Empty &rhs); //赋值运算符
};

左值和右值

什么是智能指针，有哪几种，作用，实现原理

如何避免循环依赖

若存在两个类A、B使得A类中含有B类的对象且B类中包含A类的对象，则称A、B之间存在循环依赖。

class A
{
    public:
         B b;
};
class B
{
    public:
        A a;
};

若两个类之间存在循环依赖则在编译时会报错，原因是两个类中存在相互的调用，无法为两个类分配具体的空间。

下面简述几个解决循环依赖的方法。

1、使用指针代替变量声明，如

class A
{
    public:
        B *b;
};
class B
{
    public:
        A *a;
};

这样在编译时并不会报错，因为指针类型就是四个字节，在编译时编译器知道A、B类所占内存空间的大小，故在编译时不会报错。

2、既然A、B两个类相互包含说明A、B两个类的耦合度比较高，则可以将A、B声明为一个类，然后使用派生，将A、B声明为该类的子类，修改所需的变量即可。

unique_ptr 中 std::move() 作用

static 关键字的使用

1. 限制符号的作用域只在本程序文件

若变量或函数（统称符号）使用static修饰，则只能在本程序文件内使用，其他程序文件不能调用（非static的可以通过extern 关键字声明该变量是在其他文件内定义的，此文件可调用）。不加static修饰的，则默认是可以被其他程序文件调用的。

2. 指定变量的存储位置

对于函数内的变量。auto变量（函数局部变量）都是在栈内存区存放，函数结束后就自动释放。但是全局的和函数内定义的static变量都是存放在数据区的，且只存一份，只在整个程序结束后才自动释放。
由于static变量只存一份即同一地址，所以不管函数调用多少次，函数内定义static变量的语句只会在第一次调用时执行，后面调用都不执行也不再初始化，而是对该地址内的数据进行操作。

3. C++类的静态成员变量

是属于类，而不属于某个实例对象，因此也只有一个地址保存一份数据存放于数据区。在类中只是声明，并不是定义，因此不分配内存，对类用sizeof求大小也不会将static变量得大小加入。
必须在类声明的外部，以及main()函数的外部，也就是全部变量区域对类的static成员变量再次定义（定以后才分配唯一内存，此时该类静态成员变量相当于是全局的静态变量了，只是调用的时候要使用类名加::）。若只定义不赋值初始化，则默认初始化为0。

4. C++类的静态成员函数

只能调用本类的静态成员变量或函数，不能调用本类的非静态成员函数和变量。因为非静态成员函数和变量在类成员函数中调用时，都是由形参中隐含一个指向当前实例对象的this指针来调用。然而静态成员函数没有这个this形参。

const 关键字的使用

1、防止被修饰的成员的内容被改变。

2、修饰类的成员函数时，表示其为一个常函数，意味着成员函数将不能修改类成员变量的值。

3、在函数声明时修饰参数，表示在函数访问时参数（包括指针和实参）的值不会发生变化。

4、对于指针而言，可以指定指针本身为const，也可以指定指针所指的数据为const，const int *b = &a;或者int* const b = &a;修饰的都是后面的值，分别代表*b和b不能改变。

5、const 可以替代c语言中的#define 宏定义，好处是在log中可以打印出BUFFER_SIZE 的值，而宏定义的则是不能

#define  BUFFER_SIZE  512
const int BUFFER_SIZE   = 512;

注意：const数据成员必须使用成员初始化列表进行初始化。

define 和 const 的区别

1）就起作用的阶段而言： #define是在编译的预处理阶段起作用，而const是在编译、运行的时候起作用。
2）就起作用的方式而言： #define只是简单的字符串替换，没有类型检查。而const有对应的数据类型，是要进行判断的，可以避免一些低级的错误。
3）就存储方式而言：#define只是进行展开，有多少地方使用，就替换多少次，它定义的宏常量在内存中有若干个备份；const定义的只读变量在程序运行过程中只有一份备份。
4）从代码调试的方便程度而言： const常量可以进行调试的，define是不能进行调试的，因为在预编译阶段就已经替换掉了。

面向对象的设计原则

1)单一职责原则,一个合理的类，应该仅有一个引起它变化的原因，即单一职责,就是设计的这个类功能应该只有一个;

　　优点：消除耦合，减小因需求变化引起代码僵化。

2) 开-闭原则，讲的是设计要对扩展有好的支持，而对修改要严格限制。即对扩展开放，对修改封闭。

　　优点：降低了程序各部分之间的耦合性，其适应性、灵活性、稳定性都比较好。当已有软件系统需要增加新的功能时，不需要对作为系统基础的抽象层进行修改，只需要在原有基础上附加新的模块就能实现所需要添加的功能。增加的新模块对原有的模块完全没有影响或影响很小，这样就无须为原有模块进行重新测试。

3) 里氏代换原则，很严格的原则，规则是“子类必须能够替换基类，否则不应当设计为其子类。”也就是说，一个软件实体如果使用的是一个父类的话，那么一定适用于其子类，而且它察觉不出父类对象和子类对象的区别。也就是说，在软件里面，把父类都替换成它的子类，程序的行为没有变化。

　　优点：可以很容易的实现同一父类下各个子类的互换，而客户端可以毫不察觉。

4) 依赖倒换原则，“设计要依赖于抽象而不是具体化”。换句话说就是设计的时候我们要用抽象来思考，而不是一上来就开始划分我需要哪些哪些类，因为这些是具体。

“High level modules should not depend upon low level modules, both should depend upon abstractions. Abstractions should not depend upon details, details should depend upon abstractions.”

高层模块不应该依赖低层模块，它们都应该依赖抽象。抽象不应该依赖于细节，细节应该依赖于抽象。

另一种表述为：要针对接口编程，不要针对实现编程。即“Program to an interface, not an implementation.”

　　优点：人的思维本身实际上就是很抽象的，我们分析问题的时候不是一下子就考虑到细节，而是很抽象的将整个问题都构思出来，所以面向抽象设计是符合人的思维的。另外这个原则会很好的支持（开闭原则）OCP，面向抽象的设计使我们能够不必太多依赖于实现，这样扩展就成为了可能，这个原则也是另一篇文章《Design by Contract》的基石。

5) 接口隔离原则，“将大的接口打散成多个小接口”，让系统解耦，从而容易重构，更改和重新部署。

　　优点：会使一个软件系统功能扩展时，修改的压力不会传到别的对象那里。

6) 迪米特法则或最少知识原则，这个原则首次在Demeter系统中得到正式运用，所以定义为迪米特法则。它讲的是“一个对象应当尽可能少的去了解其他对象”。

　　优点：消除耦合。

好了，面向对象的六大原则就介绍到这里了。其实，我们不难发现，六大原则虽说是原则，但它们并不是强制性的，更多的是建议。遵照这些原则固然能帮助我们更好的规范我们的系统设计和代码习惯，但并不是所有的场景都适用，就例如接口隔离原则，在现实系统开发中，我们很难完全遵守一个模块一个接口的设计，否则业务多了就会出现代码设计过度的情况，让整个系统变得过于庞大，增加了系统的复杂度，甚至影响自己的项目进度，得不偿失啊。

所以，还是那句话，在合适的场景选择合适的技术！