C++面经总结

仅供自己学习使用，侵删~

C++11有哪些新特性？

1.auto关键字：编译器可以根据初始值自动推导出类型。但是不能用于函数传参以及数组类型的推导
2.nullptr关键字：nullptr是一种特殊类型的字面值，它可以被转换成任意其它的指针类型；而NULL一般被宏定义为0，在遇到重载时可能会出现问题。
3.智能指针：C++11新增了std::shared_ptr、std::weak_ptr等类型的智能指针，用于解决内存管理的问题。
4.初始化列表：使用初始化列表{}来对类进行初始化
C++11规定可以为数据成员提供一个类内初始值，可以放在{}或者=右边，但是不能用（）进行初始化
5.右值引用：基于右值引用可以实现移动语义和完美转发，消除两个对象交互时不必要的对象拷贝，节省运算存储资源，提高效率
6.atomic原子操作：用于多线程资源互斥操作
7.新增STL容器array以及tuple
8.decltype简化返回类型定义

泛型编程：

1.C++两种抽象方法

（1）面向对象编程
封装（Encapsulation）
继承（Inheritance）
多态（Polymorphism）
（2）泛型编程
概念（concepts）
模型化（modeling）
强化（refinement）

2.泛型编程概念

    泛型编程(Generic Programming) 指在多种数据类型上皆可操作。和面向对象编程不同，它并不要求额外的间接层来调用函数，而是使用完全一般化并可重复使用的算算效率与针对某特定数据类型而设计的算法相同。
（1）概念(concepts)
    类型必须满足的一组条件。基本的concepts中有赋值、默认构造、相等比较、小于判断等。
（2）模型化(modeling)
    当类型满足这个条件，即为该concepts的一个model。
    如果能够复制类型X的值，或者赋给X对象一个新值的话，则类型X是Assignable的一个model。
（3）强化(refinement)
   如果concept  C2满足concept  C1的所有条件，再加上其他额外条件，则C2是C1的强化（refinement）。

3.泛型编程实现

（1）模板
函数模板：
1) 函数模板并不是真正的函数，它只是C++编译生成具体函数的一个模子。
2) 函数模板本身并不生成函数，实际生成的函数是替换函数模板的那个函数，比如上例中的add(sum1,sum2)，
这种替换是编译期就绑定的。
3) 函数模板不是只编译一份满足多重需要，而是为每一种替换它的函数编译一份。
4) 函数模板不允许自动类型转换。
5) 函数模板不可以设置默认模板实参。比如template <typename T=0>不可以。
类模板
1) 类模板不是真正的类，它只是C++编译器生成具体类的一个模子。
2) 类模板可以设置默认模板实参。
（2）STL
    STL(Standard Template Library，标准模板库) 是泛型编程思想的实现，于1994年被纳入C++标准程序库。STL是一种高效、泛型、可交互操作的软件组件，巨大，而且可以扩充，它包含很多计算机基本算法和数据结构，而且将算法与数据结构完全分离，其中算法是泛型的，不与任何特定数据结构或对象类型系在一起。

    STL以迭代器(Iterators)和容器(Containers)为基础，是一种泛型算法(Generic Algorithms)库，容器的存在使这些算法有东西可以操作。STL包含泛型算法(algorithms)、泛型指针(iterators)、泛型容器(containers)、函数对象(function objects)。

    迭代器(Iterators)是STL的核心，它们是泛型指针，是一种指向其他对象(objects)的对象，迭代器能够遍历由对象所形成的区间(range)。

迭代器一般分为五种：
Input Iterator     只读，单向移动，如STL中的istream\_iterator。
Output Iterator   只写，单向移动，如STL中的ostream\_iterator。
Forward Iterator   具有读、写性，单向移动。
Bidirections Iterator   具有读、写性，双向移动。
​​​​​​​Random Access Iterator   具有读、写性，随机访问        

4.泛型编程优缺点

（1）通用性强
泛型算法是建立在语法一致性上，运用到的类型集是无限的/非绑定的。
（2）效率高
编译期能确定静态类型信息，其效率与针对某特定数据类型而设计的算法相同。
（3）类型检查严
静态类型信息被完整的保存在了编译期，编译期发觉更多潜在的错误。
（4）二进制复用性差
泛型算法是建立在语法一致性上，语法是代码层面的，语法上的约定无法体现在二进制层面。泛型算法实现的库，其源代码基本上是必须公开的。而传统的C库全是以二进制形式发布的。

C++中的头文件一般应该包含哪些东西

预处理命令(各种以#开头的命令）
函数声明（也叫函数原型）
类，结构体回，联合定义（可以声明定义，答但不能建对象）
模板定义。
如果一个或多个变量需要随头文件一起被引用者使用，则可以使用"extern 变量类型 变量名;"加入头文件进行引用，但应在cpp文件中定义此变量，通常都反对此种方法进行变量的引用。
一般是结构体，函数声明定义，封装等
可以包含宏定义、类定义、结构体定义、模板定义、全局变量声明，函数声明、内联函数定义等。
不要包含全局变量定义，函数定义。
其实从本质上讲，只需要明白一件事：头文件是用来被别人包含的，因此同一个头文件极有可能被两个以上的cpp文件所包含（比如<iostream>就常被多个cpp文件包含）。因此凡是在两个编译单元重复出现两次会出错的东西都不要放在.h中。

new和malloc的区别：

1.属性：new/delete是C++关键字，需要编译器支持。malloc/free是库函数，需要头文件支持（#include <stdlib.h>(Linux下)，）。
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就可以不位于堆中。

new申请的内存，可以用free释放吗

可以，但不安全，通过 free 调用释放 new 申请的内存并不总是能正确的释放所有申版请的内存。因为使用 free 方法释权放内存时并不会调用实例的析构函数，此时如果实例中有动态申请的内存将因为析构函数没有被调用而没有得到释放，从而导致内存泄漏。而通常你不一定总能知道该类中是否使用了动态内存，因此最佳的做法是 new 与 delete 搭配使用。
当然可以了。delete只是c++的一个全局重载操作符。他只是在free前调用对象的析构方法。
但是new申请的内存用free释放则不会调用对象的析构方法。当然如果你是一个非对象类型，那可以。

const函数会访问非const的成员吗

构造函数有返回值吗

windows下怎么判断一个进程是否卡死

4种类型转换：

1.const_cast
用于将const变量转为非const
2.static_cast
用于各种隐式转换，比如非const转const，void*转指针等, static_cast能用于多态向上转化，如果向下转能成功但是不安全，结果未知；
3.dynamic_cast
用于动态类型转换。只能用于含有虚函数的类，用于类层次间的向上和向下转化。只能转指针或引用。向下转化时，如果是非法的对于指针返回NULL，对于引用抛异常。
向上转换：指的是子类向基类的转换
向下转换：指的是基类向子类的转换
它通过判断在执行到该语句的时候变量的运行时类型和要转换的类型是否相同来判断是否能够进行向下转换。
4、reinterpret_cast
几乎什么都可以转，比如将int转指针，可能会出问题，尽量少用；
注释：为什么不使用C的强制转换
C的强制转换表面上看起来功能强大什么都能转，但是转化不够明确，不能进行错误检查，容易出错。

堆和栈的区别：

1.管理方式：对于栈来讲，是由编译器自动管理，无需我们手工控制；对于堆来 说，释放工作由程序员控制，容易产生memory leak。
2.空间大小：一般来讲在32位系统下，堆内存可以达到4G的空间，从这个角度来看 堆内存几乎是没有什么限制的。但是对于栈来讲，一般都是有一定的空间大小的，例如，在VC6下面，默认的栈空间大小是1M。当然，这个值可以修改。
3.碎片问题：对于堆来讲，频繁的new/delete势必会造成内存空间的不连续，从而造成大量的碎片，使程序效率降低。对于栈来讲，则不会存在这个问 题，因为栈是先进后出的队列，他们是如此的一一对应，以至于永远都不可能有一个内存块从栈中间弹出，在他弹出之前，在他上面的后进的栈内容已经被弹出，详 细的可以参考数据结构。
4.生长方向：对于堆来讲，生长方向是向上的，也就是向着内存地址增加的方向；对于栈来讲，它的生长方向是向下的，是向着 内存地址减小的方向增长。
5. 分配方式：堆都是动态分配的，没有静态分配的堆。栈有2种分配方式：静态分配和动态分配。静态分配是编译器完成的， 比如局部变量的分配。动态分配由malloca函数进行分配，但是栈的动态分配和堆是不同的，他的动态分配是由编译器进行释放，无需我们手工实现。
6.分配效率：栈是机器系统提供的数据结构，计算机会在底层对栈提供支持：分配专门的寄存器存放栈的地址，压栈出栈都有专门的指令执行，这就决定了栈的效率 比较高。堆则是C/C++函数库提供的，它的机制是很复杂的，例如为了分配一块内存，库函数会按照一定的算法（具体的算法可以参考数据结构/操作系统）在 堆内存中搜索可用的足够大小的空间，如果没有足够大小的空间（可能是由于内存碎片太多），就有可能调用系统功能去增加程序数据段的内存空间，这样就有机会 分 到足够大小的内存，然后进行返回。显然，堆的效率比栈要低得多。
从这里我们可以看到，堆和栈相比，由于大量new/delete的使用， 容易造成大量的内存碎片；由于没有专门的系统支持，效率很低；由于可能引发用户态和核心态的切换，内存的申请，代价变得更加昂贵。所以栈在程序中是应用最 广泛的，就算是函数的调用也利用栈去完成，函数调用过程中的参数，返回地址， EBP和局部变量都采用栈的方式存放。所以，我们推荐大家尽量用栈，而不是用堆。
堆的数据结构：
堆是一棵完全二叉树（如果一共有h层，那么1~h-1层均满，在h层可能会连续缺失若干个右叶子）。
1）小根堆
若根节点存在左子女则根节点的值小于左子女的值；若根节点存在右子女则根节点的值小于右子女的值。
2）大根堆
若根节点存在左子女则根节点的值大于左子女的值；若根节点存在右子女则根节点的值大于右子女的值

1.建堆：
a.找到最后一个结点的父节点，数组下标为（n-1）/2,然后“完全下沉”
b.从上面那个结点挨个调整到第一个节点。
也就是每个节点做 ”完全下沉“ 操作，就是要下沉 每一个变动了的结点，直至到达尾结点或者符合条件。

2.堆下沉：（完全下沉，连锁下沉）
一定是要把这个结点换过来的结点 继续检查交换 ，直到不能再交换 或者 到达二叉树末尾
也就是不是只交换一次，是要把所有变动了的结点都进行检查，直至都符合条件。是一个连锁检查。

3.堆上浮：（完全上浮，连锁上浮）
这里不用判断是左枝还是右枝，因为如果是左枝直接比较；
如果是右枝，因为原来的小顶堆是稳定的，那么左枝肯定要比父节点大，所以肯定不会是左枝移上去，唯一有可能移上去只能是右枝，
所以不用判断左右枝，直接处理新建的结点就行
要注意，一定是要把这个结点换过来的结点 继续检查交换 ，直到不能再交换 或者 到达二叉树顶点
上浮与下沉一样，也是完全上浮。也就是不是只交换一次，是要把所有变动了的结点都进行检查，直至都符合条件。是一个连锁检查

4.堆插入：
插尾:
在最后一个之后插入，
然后对此结点作完全上浮：
5.堆删除：
砍头：
堆删除是 砍掉 父节点。去掉父节点后，为了维护堆的形式，然后把最后一个结点挪到父节点，然后重新 下插父节点。
6.堆排序：
就是循环删除操作：
a.砍头
b.尾（结点）补头（节点）
c头（结点）下沉
重复abc

a.首先可以看到堆建好之后堆中第0个数据是堆中最小的数据。
b.取出这个数据再执行下堆的删除操作。（也就是去掉头节点，然后把尾结点补上来，进行下插，重新调整好堆）
c.这样堆中第0个数据又是堆中最小的数据，重复上述步骤直至堆中只有一个数据时就直接取出这个数据

STL 的实现：

STL
STL
1.vector 底层数据结构为数组 ，支持快速随机访问
2.list 底层数据结构为双向链表，支持快速增删
3.deque 底层数据结构为一个中央控制器和多个缓冲区，支持首尾（中间不能）快速增删，也支持随机访问
4.stack 底层一般用list或deque实现，封闭头部即可，不用vector的原因应该是容量大小有限制，扩容耗时
5.queue 底层一般用list或deque实现，封闭头部即可，不用vector的原因应该是容量大小有限制，扩容耗时
（stack和queue其实是适配器,而不叫容器，因为是对容器的再封装）
6.priority_queue 的底层数据结构一般为vector为底层容器，堆heap为处理规则来管理底层容器实现
7.set 底层数据结构为红黑树，有序，不重复
8.multiset 底层数据结构为红黑树，有序，可重复
9.map 底层数据结构为红黑树，有序，不重复
10.multimap 底层数据结构为红黑树，有序，可重复
11.hash_set 底层数据结构为hash表，无序，不重复
12.hash_multiset 底层数据结构为hash表，无序，可重复
13.hash_map 底层数据结构为hash表，无序，不重复
14.hash_multimap 底层数据结构为hash表，无序，可重复
unordered_map 底层为哈希表
在STL中基本容器有: vector、list、deque、set、map
set 和map都是无序的保存元素,只能通过它提供的接口对里面的元素进行访问
set:集合, 用来判断某一个元素是不是在一个组里面,使用的比较少
map:映射,相当于字典,把一个值映射成另一个值,如果想创建字典的话使用它好了
底层采用的是树型结构,多数使用平衡二叉树实现,查找某一值是常数时间,遍历起来效果也不错, 只是每次插入值的时候,会重新构成底层的平衡二叉树,效率有一定影响.
vector、list、deque是有序容器
deque是一个双端队列(double-ended queue)，也是在堆中保存内容的.它的保存形式如下:
[堆1]
...
[堆2]
...
[堆3]
每个堆保存好几个元素,然后堆和堆之间有指针指向,看起来像是list和vector的结合品.
它支持[]操作符，也就是支持随即存取，可以让你在前面快速地添加删除元素,或是在后面快速地添加删除元素,然后还可以有比较高的随机访问速度,和vector的效率相差无几，它支持在两端的操作：push_back,push_front,pop_back,pop_front等，并且在两端操作上与list的效率也差不多。
在标准库中vector和deque提供几乎相同的接口,在结构上它们的区别主要在于这两种容器在组织内存上不一样,deque是按页或块来分配存储器的,每页包含固定数目的元素.相反vector分配一段连续的内存,vector只是在序列的尾段插入元素时才有效率,而deque的分页组织方式即使在容器的前端也可以提供常数时间的insert和erase操作,而且在体积增长方面也比vector更具有效率
总结：
vector是可以快速地在最后添加删除元素,并可以快速地访问任意元素
list是可以快速地在所有地方添加删除元素,但是只能快速地访问最开始与最后的元素
deque在开始和最后添加元素都一样快,并提供了随机访问方法,像vector一样使用[]访问任意元素,但是随机访问速度比不上vector快,因为它要内部处理堆跳转。
deque也有保留空间.另外,由于deque不要求连续空间,所以可以保存的元素比vector更大,这点也要注意一下.还有就是在前面和后面添加元素时都不需要移动其它块的元素,所以性能也很高。
因此在实际使用时，如何选择这三个容器中哪一个，应根据你的需要而定，一般应遵循下面的原则：
**1、如果你需要高效的随即存取，而不在乎插入和删除的效率，使用vector
2、如果你需要大量的插入和删除，而不关心随即存取，则应使用list
3、如果你需要随即存取，而且关心两端数据的插入和删除，则应使用deque。**

哈希表

哈希表是一种使用哈希函数组织数据，以支持快速插入和搜索的数据结构。
有两种不同类型的哈希表：哈希集合和哈希映射。
哈希集合是集合数据结构的实现之一，用于存储非重复值。
哈希映射是映射 数据结构的实现之一，用于存储(key, value)键值对。
在标准模板库的帮助下，哈希表是易于使用的。大多数常见语言（如Java，C ++ 和 Python）都支持哈希集合和哈希映射。
通过选择合适的哈希函数，哈希表可以在插入和搜索方面实现出色的性能。

hash_map和map的区别在哪里？

• 构造函数。hash_map需要hash函数，等于函数；map只需要比较函数(小于函数).
• 存储结构。hash_map采用hash表存储，map一般采用红黑树(RB Tree)实现。因此其memory数据结构是不一样的。

什么时候需要用hash_map，什么时候需要用map?

总体来说，hash_map 查找速度会比map快，而且查找速度基本和数据数据量大小，属于常数级别;而map的查找速度是log(n)级别。并不一定常数就比log(n)小，hash还有hash函数的耗时，明白了吧，如果你考虑效率，特别是在元素达到一定数量级时，考虑考虑hash_map。但若你对内存使用特别严格，希望程序尽可能少消耗内存，那么一定要小心，hash_map可能会让你陷入尴尬，特别是当你的hash_map对象特别多时，你就更无法控制了，而且hash_map的构造速度较慢。

现在知道如何选择了吗？权衡三个因素: 查找速度, 数据量, 内存使用。

hash_map线程不安全

例如：A和B插入的Key-Value中key的hashcode是相同的,这说明该键值对将会插入到Table的同一个下标的,也就是会发生哈希碰撞。
A线程要插入的时候阻塞了，B以为还是null会先插入，等A运行时会接着执行插入操作，则会覆盖B的插入结果

vector的实现原理：

vector的数据安排及操作方式与array非常相似。两者的唯一差别在于空间运用的灵活性。 array是静态空间，一旦配置好了就不能改变了，如果程序需要一个更大的array，只能自己再申请一个更大的array，然后将以前的array中的内容全部拷贝到新的array中。
vector是动态空间，随着元素的加入，它的内部机制会自动扩充空间以容纳新的元素。vector的关键技术在于对大小的控制以及重新分配时的数据移动效率。
vector采用的数据结构是线性的连续空间，他以两个迭代器start和finish分别指向配置得来的连续空间中目前已将被使用的空间。迭代器end_of_storage指向整个连续的尾部。
vector在增加元素时，如果超过自身最大的容量，vector则将自身的容量扩充为原来的两倍。扩充空间需要经过的步骤：重新配置空间，元素移动，释放旧的内存空间。一旦vector空间重新配置，则指向原来vector的所有迭代器都失效了，因为vector的地址改变了。

Array&List：数组和链表的区别：

数组的特点： 数组是将元素在内存中连续存放，由于每个元素占用内存相同，可以通过下标迅速访问数组中任何元素。数组的插入数据和删除数据效率低，插入数据时，这个位置后面的数据在内存中都要向后移。删除数据时，这个数据后面的数据都要往前移动。但数组的随机读取效率很高。因为数组是连续的，知道每一个数据的内存地址，可以直接找到给地址的数据。如果应用需要快速访问数据，很少或不插入和删除元素，就应该用数组。数组需要预留空间，在使用前要先申请占内存的大小，可能会浪费内存空间。并且数组不利于扩展，数组定义的空间不够时要重新定义数组。
链表的特点： 链表中的元素在内存中不是顺序存储的，而是通过存在元素中的指针联系到一起。比如：上一个元素有个指针指到下一个元素，以此类推，直到最后一个元素。如果要访问链表中一个元素，需要从第一个元素开始，一直找到需要的元素位置。但是增加和删除一个元素对于链表数据结构就非常简单了，只要修改元素中的指针就可以了。如果应用需要经常插入和删除元素你就需要用链表数据结构了。不指定大小，扩展方便。链表大小不用定义，数据随意增删。
**数组的优点： 1. 随机访问性强 2. 查找速度快
数组的缺点: 1. 插入和删除效率低 2. 可能浪费内存 3. 内存空间要求高，必须有足够的连续内存空间。 4. 数组大小固定，不能动态拓展
链表的优点: 1. 插入删除速度快 2. 内存利用率高，不会浪费内存 3. 大小没有固定，拓展很灵活。
链表的缺点: 不能随机查找，必须从第一个开始遍历，查找效率低**

vector和list的区别与联系：

1、概念：
1）Vector
连续存储的容器，动态数组，在堆上分配空间
底层实现：数组
两倍容量增长：vector 增加（插入）新元素时，如果未超过当时的容量，则还有剩余空间，那么直接添加到最后（插入指定位置），然后调整迭代器。如果没有剩余空间了，则会重新配置原有元素个数的两倍空间，然后将原空间元素通过复制的方式初始化新空间，再向新空间增加元素，最后析构并释放原空间，之前的迭代器会失效。
性能：
访问：O(1)
插入：在最后插入（空间够）：很快
在最后插入（空间不够）：需要内存申请和释放，以及对之前数据进行拷贝。
在中间插入（空间够）：内存拷贝
在中间插入（空间不够）：需要内存申请和释放，以及对之前数据进行拷贝。
删除：在最后删除：很快
在中间删除：内存拷贝
适用场景：经常随机访问，且不经常对非尾节点进行插入删除。
2）、List
动态链表，在堆上分配空间，每插入一个元数都会分配空间，每删除一个元素都会释放空间。
底层：双向链表
性能：
访问：随机访问性能很差，只能快速访问头尾节点。
插入：很快，一般是常数开销
删除：很快，一般是常数开销
适用场景：经常插入删除大量数据
2、区别：
1）vector底层实现是数组；list是双向链表。
2）vector支持随机访问，list不支持。
3）vector是顺序内存，list不是。
4）vector在中间节点进行插入删除会导致内存拷贝，list不会。
5）vector一次性分配好内存，不够时才进行2倍扩容；list每次插入新节点都会进行内存申请。
6）vector随机访问性能好，插入删除性能差；list随机访问性能差，插入删除性能好。
3、应用
vector拥有一段连续的内存空间，因此支持随机访问，如果需要高效的随即访问，而不在乎插入和删除的效率，使用vector。
list拥有一段不连续的内存空间，如果需要高效的插入和删除，而不关心随机访问，则应使用list。

Stack和Queue的区别：

栈（Stack）和队列（Queue）是两种操作受限的线性表。
（线性表：线性表是一种线性结构，它是一个含有n≥0个结点的有限序列，同一个线性表中的数据元素数据类型相同并且满足“一对一”的逻辑关系。
“一对一”的逻辑关系指的是对于其中的结点，有且仅有一个开始结点没有前驱但有一个后继结点，有且仅有一个终端结点没有后继但有一个前驱结点，其它的结点都有且仅有一个前驱和一个后继结点。）
这种受限表现在：栈的插入和删除操作只允许在表的尾端进行（在栈中成为“栈顶”），满足“FIFO：First In Last Out”；队列只允许在表尾插入数据元素，在表头删除数据元素,满足“First In First Out”。
栈与队列的相同点：
1.都是线性结构。
2.插入操作都是限定在表尾进行。
3.都可以通过顺序结构和链式结构实现。
4.插入与删除的时间复杂度都是O（1），在空间复杂度上两者也一样。
5.多链栈和多链队列的管理模式可以相同。
栈与队列的不同点：
1.删除数据元素的位置不同：栈的删除操作在表尾进行，队列的删除操作在表头进行。
2.应用场景不同：常见栈的应用场景包括括号问题的求解，表达式的转换和求值，函数调用和递归实现，深度优先搜索遍历等；常见的队列的应用场景包括计算机系统中各种资源的管理，消息缓冲器的管理和广度优先搜索遍历等。
3.顺序栈能够实现多栈空间共享，而顺序队列不能。

map 和 hashMap 底层实现：

1、Map映射，map 的所有元素都是 pair，同时拥有实值（value）和键值（key）。pair 的第一元素被视为键值，第二元素被视为实值。所有元素都会根据元素的键值自动被排序。不允许键值重复。
底层实现：红黑树
适用场景：有序键值对不重复映射
2、Multimap
多重映射。multimap 的所有元素都是 pair，同时拥有实值（value）和键值（key）。pair 的第一元素被视为键值，第二元素被视为实值。所有元素都会根据元素的键值自动被排序。允许键值重复。
底层实现：红黑树
适用场景：有序键值对可重复映射
3、unordered map
底层结构是哈希表，适用于无序映射

map和set区别在于：

（1）map中的元素是key-value（关键字—值）对：关键字起到索引的作用，值则表示与索引相关联的数据；Set与之相对就是关键字的简单集合，set中每个元素只包含一个关键字。
（2）set的迭代器是const的，不允许修改元素的值；map允许修改value，但不允许修改key。其原因是因为map和set是根据关键字排序来保证其有序性的，如果允许修改key的话，那么首先需要删除该键，然后调节平衡，再插入修改后的键值，调节平衡，如此一来，严重破坏了map和set的结构，导致iterator失效，不知道应该指向改变前的位置，还是指向改变后的位置。所以STL中将set的迭代器设置成const，不允许修改迭代器的值；而map的迭代器则不允许修改key值，允许修改value值。
（3）map支持下标操作，set不支持下标操作。map可以用key做下标，map的下标运算符[ ]将关键码作为下标去执行查找，如果关键码不存在，则插入一个具有该关键码和mapped_type类型默认值的元素至map中，因此下标运算符[ ]在map应用中需要慎用，const_map不能用，只希望确定某一个关键值是否存在而不希望插入元素时也不应该使用，mapped_type类型没有默认值也不应该使用。如果find能解决需要，尽可能用find。
红黑树实现和平衡二叉树
1、红黑树：
红黑树是一种二叉查找树，但在每个节点增加一个存储位表示节点的颜色，可以是红或黑（非红即黑）。通过对任何一条从根到叶子的路径上各个节点着色的方式的限制，红黑树确保没有一条路径会比其它路径长出两倍，因此，红黑树是一种弱平衡二叉树，相对于要求严格的AVL树来说，它的旋转次数少，所以对于搜索，插入，删除操作较多的情况下，通常使用红黑树。
性质：
1.每个节点非红即黑
2.根节点是黑的;
3.每个叶节点（叶节点即树尾端NULL指针或NULL节点）都是黑的;
4.如果一个节点是红色的，则它的子节点必须是黑色的。
5.对于任意节点而言，其到叶子点树NULL指针的每条路径都包含相同数目的黑节点;
2、平衡二叉树（AVL树）：
红黑树是在AVL树的基础上提出来的。
平衡二叉树又称为AVL树，是一种特殊的二叉排序树。其左右子树都是平衡二叉树，且左右子树高度之差的绝对值不超过1。
AVL树中所有结点为根的树的左右子树高度之差的绝对值不超过1。
将二叉树上结点的左子树深度减去右子树深度的值称为平衡因子BF，那么平衡二叉树上的所有结点的平衡因子只可能是-1、0和1。只要二叉树上有一个结点的平衡因子的绝对值大于1，则该二叉树就是不平衡的。
3、红黑树较AVL树的优点：
AVL 树是高度平衡的，频繁的插入和删除，会引起频繁的rebalance，导致效率下降；红黑树不是高度平衡的，算是一种折中，插入最多两次旋转，删除最多三次旋转。
所以红黑树在查找，插入删除的性能都是O(logn)，且性能稳定，所以STL里面很多结构包括map底层实现都是使用的红黑树。

海量数据如何去取最大的k个：

1.直接全部排序：（只适用于内存够的情况） 当数据量较小的情况下，内存中可以容纳所有数据。则最简单也是最容易想到的方法是将数据全部排序，然后取排序后的数据中的前K个。这种方法对数据量比较敏感，当数据量较大的情况下，内存不能完全容纳全部数据，这种方法便不适应了。即使内存能够满足要求，该方法将全部数据都排序了，而题目只要求找出top K个数据，所以该方法并不十分高效，不建议使用。
2.快速排序的变形 :（只使用于内存够的情况） 这是一个基于快速排序的变形，因为第一种方法中说到将所有元素都排序并不十分高效，只需要找出前K个最大的就行。 这种方法类似于快速排序，首先选择一个划分元，将比这个划分元大的元素放到它的前面，比划分元小的元素放到它的后面，此时完成了一趟排序。 如果此时这个划分元的序号index刚好等于K，那么这个划分元以及它左边的数，刚好就是前K个最大的元素；如果index > K，那么前K大的数据在index的左边，那么就继续递归的从index-1个数中进行一趟排序；如果index < K，那么再从划分元的右边继续进行排序，直到找到序号index刚好等于K为止。再将前K个数进行排序后，返回Top K个元素。这种方法就避免了对除了Top K个元素以外的数据进行排序所带来的不必要的开销。
3.最小堆法: 这是一种局部淘汰法。先读取前K个数，建立一个最小堆。然后将剩余的所有数字依次与最小堆的堆顶进行比较，如果小于或等于堆顶数据，则继续比较下一个；否则，删除堆顶元素，并将新数据插入堆中，重新调整最小堆。当遍历完全部数据后，最小堆中的数据即为最大的K个数。
4.分治法: 将全部数据分成N份，前提是每份的数据都可以读到内存中进行处理，找到每份数据中最大的K个数。此时剩下N K个数据，如果内存不能容纳 N K个数据，则再继续分治处理，分成M份，（这里M要大于N才行）找出每份数据中最大的K个数，如果M*K个数仍然不能读到内存中，则继续分治处理。直到剩余的数可以读入内存中，那么可以对这些数使用快速排序的变形或者归并排序进行处理。
5.Hash法: 如果这些数据中有很多重复的数据，可以先通过hash法，把重复的数去掉。这样如果重复率很高的话，会减少很大的内存用量，从而缩小运算空间。处理后的数据如果能够读入内存，则可以直接排序；否则可以使用分治法或者最小堆法来处理数据。
实际运行：

实际上，最优的解决方案应该是最符合实际设计需求的方案，在时间应用中，可能有足够大的内存，那么直接将数据扔到内存中一次性处理即可，也可能机器有多个核，这样可以采用多线程处理整个数据集。
下面针对不容的应用场景，分析了适合相应应用场景的解决方案。
（1）单机+单核+足够大内存
如果需要查找10亿个查询次（每个占8B）中出现频率最高的10个，考虑到每个查询词占8B，则10亿个查询次所需的内存大约是10^9 \* 8B=8GB内存。如果有这么大内存，直接在内存中对查询次进行排序，顺序遍历找出10个出现频率最大的即可。这种方法简单快速，使用。然后，也可以先用HashMap求出每个词出现的频率，然后求出频率最大的10个词。

（2）单机+多核+足够大内存
这时可以直接在内存总使用Hash方法将数据划分成n个partition，每个partition交给一个线程处理，线程的处理逻辑同（1）类似，最后一个线程将结果归并。

该方法存在一个瓶颈会明显影响效率，即数据倾斜。每个线程的处理速度可能不同，快的线程需要等待慢的线程，最终的处理速度取决于慢的线程。而针对此问题，解决的方法是，将数据划分成c×n个partition（c>1），每个线程处理完当前partition后主动取下一个partition继续处理，知道所有数据处理完毕，最后由一个线程进行归并。

（3）单机+单核+受限内存
这种情况下，需要将原数据文件切割成一个一个小文件，如次啊用hash(x)%M，将原文件中的数据切割成M小文件，如果小文件仍大于内存大小，继续采用Hash的方法对数据文件进行分割，知道每个小文件小于内存大小，这样每个文件可放到内存中处理。采用（1）的方法依次处理每个小文件。

（4）多机+受限内存
这种情况，为了合理利用多台机器的资源，可将数据分发到多台机器上，每台机器采用（3）中的策略解决本地的数据。可采用hash+socket方法进行数据分发。

从实际应用的角度考虑，（1）（2）（3）（4）方案并不可行，因为在大规模数据处理环境下，作业效率并不是首要考虑的问题，算法的扩展性和容错性才是首要考虑的。算法应该具有良好的扩展性，以便数据量进一步加大（随着业务的发展，数据量加大是必然的）时，在不修改算法框架的前提下，可达到近似的线性比；算法应该具有容错性，即当前某个文件处理失败后，能自动将其交给另外一个线程继续处理，而不是从头开始处理。

top K问题很适合采用MapReduce框架解决，用户只需编写一个Map函数和两个Reduce 函数，然后提交到Hadoop（采用Mapchain和Reducechain）上即可解决该问题。具体而言，就是首先根据数据值或者把数据hash(MD5)后的值按照范围划分到不同的机器上，最好可以让数据划分后一次读入内存，这样不同的机器负责处理不同的数值范围，实际上就是Map。得到结果后，各个机器只需拿出各自出现次数最多的前N个数据，然后汇总，选出所有的数据中出现次数最多的前N个数据，这实际上就是Reduce过程。对于Map函数，采用Hash算法，将Hash值相同的数据交给同一个Reduce task；对于第一个Reduce函数，采用HashMap统计出每个词出现的频率，对于第二个Reduce 函数，统计所有Reduce task，输出数据中的top K即可。

直接将数据均分到不同的机器上进行处理是无法得到正确的结果的。因为一个数据可能被均分到不同的机器上，而另一个则可能完全聚集到一个机器上，同时还可能存在具有相同数目的数据。

以下是一些经常被提及的该类问题。
（1）有10000000个记录，这些查询串的重复度比较高，如果除去重复后，不超过3000000个。一个查询串的重复度越高，说明查询它的用户越多，也就是越热门。请统计最热门的10个查询串，要求使用的内存不能超过1GB。
（2）有10个文件，每个文件1GB，每个文件的每一行存放的都是用户的query，每个文件的query都可能重复。按照query的频度排序。
（3）有一个1GB大小的文件，里面的每一行是一个词，词的大小不超过16个字节，内存限制大小是1MB。返回频数最高的100个词。
（4）提取某日访问网站次数最多的那个IP。
（5）10亿个整数找出重复次数最多的100个整数。
（6）搜索的输入信息是一个字符串，统计300万条输入信息中最热门的前10条，每次输入的一个字符串为不超过255B，内存使用只有1GB。
（7）有1000万个身份证号以及他们对应的数据，身份证号可能重复，找出出现次数最多的身份证号。

重复问题
在海量数据中查找出重复出现的元素或者去除重复出现的元素也是常考的问题。针对此类问题，一般可以通过位图法实现。例如，已知某个文件内包含一些电话号码，每个号码为8位数字，统计不同号码的个数。

本题最好的解决方法是通过使用位图法来实现。8位整数可以表示的最大十进制数值为99999999。如果每个数字对应于位图中一个bit位，那么存储8位整数大约需要99MB。因为1B=8bit，所以99Mbit折合成内存为99/8=12.375MB的内存，即可以只用12.375MB的内存表示所有的8位数电话号码的内容。

内存溢出和内存泄漏：

1.内存溢出 指程序申请内存时，没有足够的内存供申请者使用。内存溢出就是你要的内存空间超过了系统实际分配给你的空间，此时系统相当于没法满足你的需求，就会报内存溢出的错误.
内存溢出原因： 内存中加载的数据量过于庞大，如一次从数据库取出过多数据,集合类中有对对象的引用，使用完后未清空，使得不能回收代码中存在死循环或循环产生过多重复的对象实体
使用的第三方软件中的BUG ；
启动参数内存值设定的过小。
2.内存泄漏: 内存泄漏是指由于疏忽或错误造成了程序未能释放掉，不再使用的内存的情况。内存泄漏并非指内存在物理上的消失，而是应用程序分配某段内存后，由于设计错误，失去了对该段内存的控制，因而造成了内存的浪费。

内存泄漏的分类：

C++中避免内存泄露常见的解决方案
1、堆内存泄漏 （Heap leak）。对内存指的是程序运行中根据需要分配通过malloc,realloc new等从堆中分配的一块内存，再是完成后必须通过调用对应的 free或者delete 删掉。如果程序的设计的错误导致这部分内存没有被释放，那么此后这块内存将不会被使用，就会产生Heap Leak。
2、系统资源泄露（Resource Leak）。主要指程序使用系统分配的资源比如和Bitmap,handle,SOCKET等没有使用相应的函数释放掉，导致系统资源的浪费，严重可导致系统效能降低，系统运行不稳定。
3、没有将基类的析构函数定义为虚函数。当基类指针指向子类对象时，如果基类的析构函数不是virtual，那么子类的析构函数将不会被调用，子类的资源没有正确是释放，因此造成内存泄露

检测内存泄露

观察内存泄露是一个两步骤的过程。首先，使用swap命令观察还有多少可用的交换空间：
/usr/sbin/swap -s
total:17228K bytes allocated + 5396K reserved=22626K used，29548K available.
在一两分钟内键入该命令三到四次，看看可用的交换区是否在减少。还可以使用其他一些/usr/bin/*stat工具如netstat、vmstat等。如发现波段有内存被分配且从不释放，一个可能的解释就是有个进程出现了内存泄露。

C++的内存管理是怎样的？

在C++中，虚拟内存分为代码段、数据段、BSS段、堆区、文件映射区以及栈区六部分
32bitCPU可寻址4G线性空间，每个进程都有各自独立的4G逻辑地址，其中0~3G是用户态空间，3~4G是内核空间，不同进程相同的逻辑地址会映射到不同的物理地址中。其逻辑地址其划分如下：
3G用户空间和1G内核空间
静态区域：
text segment(代码段):包括只读存储区和文本区，其中只读存储区存储字符串常量，文本区存储程序的机器代码。
data segment(数据段)：存储程序中已初始化的全局变量和静态变量
bss segment：存储未初始化的全局变量和静态变量（局部+全局），以及所有被初始化为0的全局变量和静态变量，对于未初始化的全局变量和静态变量，程序运行main之前时会统一清零。即未初始化的全局变量编译器会初始化为0
动态区域：
heap（堆）： 当进程未调用malloc时是没有堆段的，只有调用malloc时采用分配一个堆，并且在程序运行过程中可以动态增加堆大小(移动break指针)，从低地址向高地址增长。分配小内存时使用该区域。 堆的起始地址由mm_struct 结构体中的start_brk标识，结束地址由brk标识。
memory mapping segment(映射区):存储动态链接库等文件映射、申请大内存（malloc时调用mmap函数）
stack（栈）：使用栈空间存储函数的返回地址、参数、局部变量、返回值，从高地址向低地址增长。在创建进程时会有一个最大栈大小，Linux可以通过ulimit命令指定。

在一个函数内开辟一个1024字节的数组，应该怎么做？这样的开辟方式会有什么样的危害？

int a[1024];
int* p = (int*)malloc(sizeof(int)*256);//开辟256个int大小的堆内存，也就是1024个字节的内存空间

C++ 初始化数组过大，可能会造成内存溢出的问题。

所以，发生了啥？为啥数组作为全局变量空间可以开那么大，作为main函数里面的局部变量却只能开那么小？

这就涉及到了C语言的内存分配问题，上课的时候都听说过，C语言占用的内存可以分为5个区：

①代码区（Text Segment）：不难理解，就是用于放置编译过后的代码的二进制机器码。

②堆区（Heap）：用于动态内存分配。一般由程序员分配和释放，若程序员不释放，结束程序时有可能由操作系统回收。（其实就是malloc()函数能够掌控的内存区域）

③栈区（Stack）:由编译器自动分配和释放，一般用来存放局部变量、函数参数（敲黑板划重点了！）。

④全局初始化数据区/静态数据区（Data Segment）：顾名思义，就是存放全局变量和静态变量的地方。这个区域被整个进程共享。

⑤未初始化数据区（BSS）：在运行时改变值。改变值（初始化）的时候，会根据它是全局变量还是局部变量，进到他们该去的区。否则会持续待在BSS里面与世无争。（待会儿会用实验来证明并感受它的存在。）
代码区和堆区不赘述，不在我关注的范围内。貌似空间大小取决于内存的大小和CPU的寻址空间。

我今天只讲一讲Stack和Data Segment

在Windows下，Data Segment的所允许的空间大小取决于剩余内存的大小，也就是说，如果电脑剩余8G内存的话，int类型的二维数组甚至可以开到46340*46340的大小；

而Stack的空间只有2M也就是210241024=2097152字节，局部变量空间顶多放得下下524288个int类型！

行吧，知道上述几个关键后，一开始的问题就不是问题了。但我想在局部中开一个大数组怎么办？很简单，将它归到Data Segment中：

#include<iostream>
using namespace std;
int main()
{
    static int dis[8000][8000];
    //代码
}

由于静态变量和全局变量一样，都是存在Data Segment中的，所以这么做，相当于把大数组开在了Data Segment中，不会因为堆栈溢出2M空间而报错了。（这样做的话，需要注意局部函数的初始化）。

△深入：BSS区的存在！

其实，文章本来在这里就要结束了，但是我闲着蛋疼，手动二分，强行找到了Stack区所能开的int数组的大小（真实情况下不可能是2M刚好），然后发现了神奇的一幕（后来才知道BSS区的存在），于是干脆就写出来了：

#include<iostream>
using namespace std;
int main()
{
    int dis[520072]; //520072
}

520072是我手动二分得到的结果，如果开520073的话会堆栈溢出（不同电脑不知道一不一样）。

520073*4/1024/1024≈1.984MB（接近2MB，没毛病）

然而，神奇的一幕出现了：

#include<iostream>
using namespace std;
int main()
{
    int dis[520072];//520072
    int a1;int a2;int a3;int a4;int a5;int a6;int a7;int a8;int a9;
    int b1;int b2;int b3;int b4;int b5;int b6;int b7;int b8;int b9;
｝

理论上，我开第520073个整型出来的时候，编译器应该报堆栈溢出的错误才对，然而并没有！然而并没有！

这就涉及到了我刚才提到的未初始化数据区（BSS）的存在了——在运行时改变值。改变值（初始化）的时候，会根据它是全局变量还是局部变量，进到他们该去的区。否则会持续待在BSS里面与世无争。

在给未初始化的变量赋值之前，它们始终待在BSS区，所以Stack区并不会溢出。而在局部定义数组的时候，数组会自动初始化为全0，所以数组在刚被定义的时候就塞进Stack区了，才会出现int dis[520073]直接报堆栈溢出的问题。

证明上述说法的代码如下：

#include<iostream>
using namespace std;
int main()
{
    int dis[520072];//520072
    int a=10；
}

这段代码在运行时会堆栈溢出。

#include<iostream>
using namespace std;
int main()
{
    int dis[520072];//520072
    int a;
    while(1){}
    a=10;
}

这段代码会正常进入循环中，始终不会报堆栈溢出。

C++三种内存分配方式

1、在栈上分配内存：函数中的临时局部变量分配在栈上，由操作系统自动分配，函数调用结束时内存也随之析构，栈内存分配运算内置于处理器的指令集中，效率很高，但是分配的内存容量有限。
2、在静态存储区分配内存，这块内存在程序编译的时候就已经分配好，用来存放常量，全局变量和static变量，内存在整个程序运行周期内都存在。
3、在堆区使用malloc或new申请内存，这种内存分配方式非常灵活，需要注意：

①申请内存后立即判断指针是否为NULL确定内存是否分配成功，如果为NULL则立即用return终止此函数，或者用exit（1）终止整个程序的运行，为new和malloc设置异常处理函数；

②为申请的内存赋初值，分配的是一段连续的内存空间的话，要防止指针下标越界；

③sizeof是操作符，不能用sizeof得到内存空间的大小，只能在申请时候记住申请的空间大小；

④在内存使用结束后必须用free或delete释放内存，注意在内存使用中如果存在指针加1或减1 的操作应特别注意，释放的内存要和申请的内存一致，放置内存泄漏，释放内存后，应该立即将指针置为NULL，不要存在野指针。

野指针

https://www.cnblogs.com/mrlsx/p/5419030.html

什么是右值引用，跟左值又有什么区别？

右值引用是C++11中引入的新特性 , 它实现了转移语义和精确传递。
它的主要目的有两个方面：
1.消除两个对象交互时不必要的对象拷贝，节省运算存储资源，提高效率。
2.能够更简洁明确地定义泛型函数。
左值和右值的概念：
左值：能对表达式取地址、或具名对象/变量。一般指表达式结束后依然存在的持久对象。
右值：不能对表达式取地址，或匿名对象。一般指表达式结束就不再存在的临时对象。
右值引用和左值引用的区别
1.左值可以寻址，而右值不可以。
2.左值可以被赋值，右值不可以被赋值，可以用来给左值赋值。
3.左值可变,右值不可变（仅对基础类型适用，用户自定义类型右值引用可以通过成员函数改变）。

strcpy和strlen

函数原型为char \strcpy(char \dest,const char \*src);
函数说明：strcpy函数会将参数src字符串拷贝至参数dest所指的地址。
参数说明：dest，我们说的出参，最终得到的字符串。src，入参，因为其有const修饰。表示在此函数中不会也不能修改src的值。
返回值：返回dest字符串的起始地址。
附加说明：如果参数dest所指的内存空间不够大，可能会造成缓冲溢出的错误情况。

特别强调：此函数很好用，可是它也很危险。如果在用的时候加上相关的长度判断，则会大大降低出此错误的危险。此函数还有一个特点，就是它在把字符串b拷贝到字符串a的时候，会在拷贝的a字符串的末尾加上一个\0结束标志。这个不同于strncpy（）函数。
strcpy有什么缺陷：
1.存在潜在越界问题
当dest的长度 < src的长度的时候，由于无法根据指针判定其所指指针的长度，故数组内存边界不可知的。因此会导致内存越界，尤其是当数组是分配在栈空间的，其越界会进入你的程序代码区，将使你的程序出现非常隐晦的异常。
2.字符串结束标志服’\0’丢失
当dest所指对象的数组长度==count的时候，调用strncpy使得dest字符结束符’\0’丢失。
3.效率较低
当count > src所指对象的长度的时候，会继续填充’\0’知道count的长度为止。
4.不能处理内存覆盖问题
不能处理dest和src内存重叠的情况。

• strncpy

函数原型为：char \strncpy(char \dest,const char \*src ,size\_t n);
函数说明：strncpy会将参数src字符串拷贝前n个字符至参数dest所指的地址。
返回值：返回参数dest的字符串起始地址。
特别强调：不要以为这个函数是个好东西，往往在定位问题时，它是罪魁祸首，到顶了，它是静态的容值函数，程序跑起来你就等着dbug吧。

strncpy的正确用法：

strncpy(dest, src, sizeof(dest))；
dest\[sizeof(dest)-1\] = ‘\0’;

1. size一定要用sizeof(dest)或sizeof(dest)-1，不可误用sizeof(src).
2. 手工填0. 务必要把dest的最后一个字节手工设置为0. 因为strncpy仅在src的长度小于dest时，对剩余的字节填0.
3. 性能问题。当dest长度远大于src时，由于strncpy会对多余的每个字节填0，会有很大的性能损失。
4. 返回值。strncpy返回dest，因而无法知道拷贝了多少个字节。

strcpy (目标串bai地址，源串的开始du地址): 从源串的开始到结尾（'\0')完全拷贝到zhi目标串dao地址
strncpy（目标串地址，源串的开始地址，n): 从源串的开始拷贝n个字符到目标串地址，n大于源串长度时，遇到'\0'结束； n小于源串长度时，到第n个字符结束，但不会在目标串尾补'\0'

strlen() 和 strcpy()函数的区别，这两个一个是返回一个C风格字符串的长度，一个是对一个C风格字符串的拷贝，两个本来功能上是不同的，此外，他们还有一些细小的区别：strlen("hello")返回的结果是5，是不包含字符串结尾处的‘\0’，但是strcpy(str1,str2)，会拷贝str2中的‘\0’
建议在使用strcpy的时候，目标数组（第一个参数）的大小应该设置为strlen（）函数返回值+1 的值，或者建议使用如下的初始化数组方式：

试题一
void test1()
{
　char string[10];
　char* str1 = "0123456789";
　strcpy( string, str1 );
}

解答：字符串str1需要11个字节才能存放下（包括末尾的结束符），而string只有10个字节的空间，strcpy会导致数组越界。

试题二
void test2()
{
　char string[10], str1[10];
　int i;
　for(i=0; i<10; i++)
　{
　　str1[i] = 'a';
　}
　strcpy( string, str1 );
}

解答：str1数组没有字符串结束符，不能算是一个字符数组，而strcpy只能对字符串进行拷贝。

试题三
void test3(char* str1)
{
　char string[10];
　if( strlen( str1 ) <= 10 )
　{
　　strcpy( string, str1 );
　}
}

解答：if(strlen(str1) <= 10)应改为if(strlen(str1) < 10)，因为strlen的结果未统计’结束符所占用的1个字节。

C++与C的联系与区别：

C++与C的联系：
　　C++是在C语言的基础上开发的一种面向对象编程语言，应用广泛。C++支持多种编程范式 －－面向对象编程、泛型编程和过程化编程。 其编程领域众广，常用于系统开发，引擎开发等应用领域，是最受广大程序员受用的最强大编程语言之一,支持类：类、封装、重载等特性!
　　C++在C的基础上增添类，C是一个结构化语言，它的重点在于算法和数据结构。C程序的设计首要考虑的是如何通过一个过程，对输入（或环境条件）进行运算处理得到输出（或实现过程（事务）控制），而对于C++，首要考虑的是如何构造一个对象模型，让这个模型能够契合与之对应的问题域，这样就可以通过获取对象的状态信息得到输出或实现过程（事务）控制。
C++与C的区别：
1、C是面向过程的语言，而C++是面向对象的语言，那么什么是面向对象？
　　面向对象：面向对象是一种对现实世界的理解和抽象的方法、思想，通过将需求要素转化为对象进行问题处理的一种思想。
2、C和C++动态管理内存的方法不一样，C是使用malloc、free函数，而C++不仅有malloc/free，还有new/delete关键字。
3、C++的类是C中没有的，C中的struct可以在C++中等同类来使用，struct和类的差别是，struct的成员默认访问修饰符是public，而类默认是private。
4、C++支持重载，而C不支持重载，C++支持重载在于C++名字的修饰符与C不同，例如在C++中函数 int f(int) 经过名字修饰之后变为_f_int,而C是_f，所以C++才会支持不同的参数调用不同的函数。
5、C++中有引用，而C没有。
6、C++全部变量的默认连接属性是外连接，而C是内连接。
7、C中用const修饰的变量不可以用在定义数组时的大小，但是C++用const修饰的变量可以。
8、C++有很多特有的输入输出流。
9、C中没有iostream这个头文件， 这是C++的标准输入输出库，相当于C的stdio.h。

C语言为什么不能函数重载

如下图：

1、原因：C语言不能函数重载与函数编译后函数名有关。
2、C语言编译后的代码名称为”\_函数名”
那么问题就出在编译这个环节上。
c语言在编译器编译的时候，在库中的名字为：\_function
而c++在编译器编译以后，在库中的名字是：\_function\_x
也就是说，c语言如果遇到重名函数，链接的时候就会报错
而c++会根据修饰规则进行选择，因为编译后的名字是不一样的。

比如两个函数声明：
void f(int x, int y)
void f()
c语言在编译后都是: \_f
而c++是: \_f 和 \_f\_int\_int
编译后函数名变化只是在原来的函数名前加了一个下划线，所以当同名的函数参数不同时，编译器无法解析到他们的不同，因为它们编译后的名称都相同，所以C语言不能函数重载。

总结：

• C语言，在符号表中的函数标识是函数本身，就会存在两个同名函数。
• C++，不是用原生的函数名，是函数名+参数（c++有函数名修饰规则，函数名+类型一起决定）

问题：只有返回值类型不同时，为什么不能函数重载?
只有返回值类型不同时，编译后的名称也不相同，为什么不能重载
1、只有返回值不同的函数，在调用时编译器不知道该调用那个。
2、每个编译器编译后的函数名称转换方式不同

• 例如：linux下是这样的Add3\_i \_i
• 其中Add—–>函数名
• 3——–>函数名有几个字符
• \_i \_i——>连个参数都是整形
• 当函数返回类型不同时，编译后的名称相同，所以不能重载

4、补充问题
先回答一个问题？编译的时候为什么只有声明没有定义不会报错？
因为编译时只会在当前工程去找定义，如果没有找到定义找到函数声明就不找了，因为编译器认为这个函数的定义有可能在其他文件里面，先把编译时没有函数定义这个问题放过去，等到链接的时候再在其它文件查找，找不到在报错。
所以我们找出验证的方法是，写函数只给函数声明，不给函数定义，然后调用，链接是会出现错误

指针和引用的区别？

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

值传递和引用传递：

值传递：
形参是实参的拷贝，改变形参的值并不会影响外部实参的值。从被调用函数的角度来说，值传递是单向的（实参->形参），参数的值只能传入，
不能传出。当函数内部需要修改参数，并且不希望这个改变影响调用者时，采用值传递。
指针传递：
形参为指向实参地址的指针，当对形参的指向操作时，就相当于对实参本身进行的操作
引用传递：
形参相当于是实参的“别名”，对形参的操作其实就是对实参的操作，在引用传递过程中，被调函数的形式参数虽然也作为局部变量在栈中开辟了内存空间，但是这时存放的是由主调函数放进来的实参变量的地址。被调函数对形参的任何操作都被处理成间接寻址，即通过栈中存放的地址访问主调函数中的实参变量。正因为如此，被调函数对形参做的任何操作都影响了主调函数中的实参变量。
引用的规则：
（1）引用被创建的同时必须被初始化（指针则可以在任何时候被初始化）。
（2）不能有NULL引用，引用必须与合法的存储单元关联（指针则可以是NULL）。
（3）一旦引用被初始化，就不能改变引用的关系（指针则可以随时改变所指的对象）。
指针传递的实质：
指针传递参数本质上是值传递的方式，它所传递的是一个地址值。值传递过程中，被调函数的形式参数作为被调函数的局部变量处理，即在栈中开辟了内存空间以存放由主调函数放进来的实参的值，从而成为了实参的一个副本。值传递的特点是被调函数对形式参数的任何操作都是作为局部变量进行，不会影响主调函数的实参变量的值。
指针传递和引用传递一般适用于：函数内部修改参数并且希望改动影响调用者。对比指针/引用传递可以将改变由形参“传给”实参（实际上就是直接在实参的内存上修改，不像值传递将实参的值拷贝到另外的内存地址中才修改）。另外一种用法是：当一个函数实际需要返回多个值，而只能显式返回一个值时，可以将另外需要返回的变量以指针/引用传递给函数，这样在函数内部修改并且返回后，调用者可以拿到被修改过后的变量，也相当于一个隐式的返回值传递吧。

关键字static作用，函数加static和不加static区别：

static关键字：
　　1.static局部变量在函数内定义，它的生存期为整个源程序，但是其作用域仍与自动变量相同，只能在定义该变量的函数内使用该变量。退出该函数后， 尽管该变量还继续存在，但不能使用它。再次调用该函数可以再次使用。
　　2.static修饰全局变量的时候，这个全局变量只能在本文件中访问，不能在其它文件中访问，即便是extern外部声明也不可以。
　　3.static修饰一个函数，则这个函数的只能在本文件中调用，不能被其他文件调用。Static修饰的局部变量存放在全局数据区的静态变量区。初始化的时候自动初始化为0；
　　（1）不想被释放的时候，可以使用static修饰。比如修饰函数中存放在栈空间的数组。如果不想让这个数组在函数调用结束释放可以使用static修饰
　 （2）考虑到数据安全性（当程想要使用全局变量的时候应该先考虑使用static）
在C++中static关键字除了具有C中的作用还有在类中的使用
在类中，static可以用来修饰静态数据成员和静态成员方法
静态数据成员：
　　（1）静态数据成员可以实现多个对象之间的数据共享，它是类的所有对象的共享成员，它在内存中只占一份空间，如果改变它的值，则各对象中这个数据成员的值都被改变。
　　（2）静态数据成员是在程序开始运行时被分配空间，到程序结束之后才释放，只要类中指定了静态数据成员，即使不定义对象，也会为静态数据成员分配空间。
　　（3）静态数据成员可以被初始化，但是只能在类体外进行初始化，若未对静态数据成员赋初值，则编译器会自动为其初始化为0
　　（4）静态数据成员既可以通过对象名引用，也可以通过类名引用。
静态成员函数：
　（1）静态成员函数和静态数据成员一样，他们都属于类的静态成员，而不是对象成员。
　（2）非静态成员函数有this指针，而静态成员函数没有this指针。
　（3）静态成员函数主要用来访问静态数据成员而不能访问非静态成员。

函数指针

1.定义
函数指针是指向函数的指针变量。
函数指针本身首先是一个指针变量，该指针变量指向一个具体的函数。这正如用指针变量可指向整型变量、字符型、数组一样，这里是指向函数。
C在编译时，每一个函数都有一个入口地址，该入口地址就是函数指针所指向的地址。有了指向函数的指针变量后，可用该指针变量调用函数，就如同用指针变量可引用其他类型变量一样，在这些概念上是大体一致的。
2.用途：
调用函数和做函数的参数，比如回调函数。
3.示例：

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

const关键字作用，const和宏定义有什么区别，用哪个？

const关键字：
1.欲阻止一个变量被改变，可使用const，在定义该const变量时，需先初始化，以后就没有机会改变他了；const修饰的成员函数表明函数调用不会对对象做出任何更改，事实上，如果确认不会对对象做更改，就应该为函数加上const限定，这样无论const对象还是普通对象都可以调用该函数。
2.对指针而言，可以指定指针本身为const，也可以指定指针所指的数据为const，或二者同时指定为const；
3.在一个函数声明中，const可以修饰形参表明他是一个输入参数，在函数内部不可以改变其值；
4.对于类的成员函数，有时候必须指定其为const类型，表明其是一个常函数，不能修改类的成员变量；
5.对于类的成员函数，有时候必须指定其返回值为const类型，以使得其返回值不为“左值”。
1.作用
1.const所修饰的内容是不可变的，比如说：const变量、const成员函数、const参数、const返回值等等，
2.const所修饰的内容具有强制保护性；可以防止代码随意改动，提高了代码的鲁棒性。
2.区别
1、const常量有数据类型，宏定义常量没有数据类型。
2、编辑器可以对const常量进行类型安全检查，而对宏常量进行字符替换没有类型安全检查，并且在替换的时候会产生意想不到的错误。
3、有些集成化的调试工具可以对const常量进行调试，但是不能对宏常量进行调试。
3.用哪一个呢？
用const关键字，因为宏定义太多会导致代码膨胀。
4.既然c++有更好用的const，为什么还要用宏定义呢？
因为const无法替代宏做为卫哨来防止文件的重复包含。

define的作用:

• 注意:

  • 宏名不能以数字开头
  • 宏在编译器编译时展开，而不是而不是预处理阶段

• 功能

  • 替换数字
  • 替换字符
  • 进行数值运算

• 何时该使用符号常量？

  • 总的来说就是你想＂一换全换＂的情况．

是字符串化的意思，出现在宏定义中的#是把跟在后面的参数转成一个字符串；

是连接符号，把参数连接在一起

虚函数

引入原因：
1、同“虚函数”；
2、在很多情况下，基类本身生成对象是不合情理的。例如，动物作为一个基类可以派生出老虎、孔雀等子类，但动物本身生成对象明显不合常理。
纯虚函数就是基类只定义了函数体，没有实现过程，定义方法如： virtual void Eat() = 0; 不要 在cpp中定义；纯虚函数相当于接口，不能直接实例话，需要派生类来实现函数定义；

有的人可能在想，定义这些有什么用啊 ，我觉得很有用，比如你想描述一些事物的属性给别人，而自己不想去实现，就可以定义为纯虚函数。说的再透彻一些。比如盖楼房，你是老板，你给建筑公司描述清楚你的楼房的特性，多少层，楼顶要有个花园什么的，建筑公司就可以按照你的方法去实现了，如果你不说清楚这些，可能建筑公司不太了解你需要楼房的特性。用纯需函数就可以很好的分工合作了

虚函数和纯虚函数区别

观点一：
类里声明为虚函数的话,这个函数是实现的，哪怕是空实现，它的作用就是为了能让这个函数在它的子类里面可以被重载，这样的话，这样编译器就可以使用后期绑定来达到多态了
纯虚函数只是一个接口，是个函数的声明而已，它要留到子类里去实现。

class A{
protected:
    void foo();//普通类函数
    virtual void foo1();//虚函数
    virtual void foo2() = 0;//纯虚函数
}

观点二：

虚函数在子类里面也可以不重载的；但纯虚必须在子类去实现，这就像Java的接口一样。通常我们把很多函数加上virtual，是一个好的习惯，虽然牺牲了一些性能，但是增加了面向对象的多态性，因为你很难预料到父类里面的这个函数不在子类里面不去修改它的实现

观点三：
虚函数的类用于“实作继承”，继承接口的同时也继承了父类的实现。当然我们也可以完成自己的实现。纯虚函数的类用于“介面继承”，主要用于通信协议方面。关注的是接口的统一性，实现由子类完成。一般来说，介面类中只有纯虚函数的。

观点四：
带纯虚函数的类叫虚基类，这种基类不能直接生成对象，而只有被继承，并重写其虚函数后，才能使用。这样的类也叫抽象类。
虚函数是为了继承接口和默认行为
纯虚函数只是继承接口，行为必须重新定义

虚函数是如何实现的？多态？

C++虚函数原理
多态的实现主要分为静态多态和动态多态，静态多态主要是重载，在编译的时候就已经确定；动态多态是用虚函数机制实现的，在运行期间动态绑定。举个例子：一个父类类型的指针指向一个子类对象时候，使用父类的指针去调用子类中重写了的父类中的虚函数的时候，会调用子类重写过后的函数，在父类中声明为加了virtual关键字的函数，在子类中重写时候不需要加virtual也是虚函数。
C++中的虚函数的作用主要是实现了多态的机制。关于多态，简而言之就是用父类 类型的指针指向其子类的实例，然后通过父类的指针调用实际子类的成员函数。
我们通过对象实例的地址得到这张虚函数表，然后就可以遍历其中函数指针，并调用相应的函数。编译器处理虚函数的方法是：为每个类对象添加一个隐藏成员，隐藏成员中保存了一个指向函数地址数组的指针，称为虚表指针（vptr），这种数组成为虚函数表（virtual function table, vtbl），即，每个类使用一个虚函数表，每个类对象用一个虚表指针。
举个例子：基类对象包含一个虚表指针，指向基类中所有虚函数的地址表。派生类对象也将包含一个虚表指针，指向派生类虚函数表。看下面两种情况：
1.如果派生类重写了基类的虚方法，该派生类虚函数表将保存重写的虚函数的地址，而不是基类的虚函数地址。
2.如果基类中的虚方法没有在派生类中重写，那么派生类将继承基类中的虚方法，而且派生类中虚函数表将保存基类中未被重写的虚函数的地址。
3.注意，如果派生类中定义了新的虚方法，则该虚函数的地址也将被添加到派生类虚函数表中。

虚函数前面加static行不行：不行

1.首先的话，静态函数是不和任何类对象或类实例相关联，所以就算给函数加上viruatl是没有任何意义的
2.静态与非静态成员函数之间有一个主要的区别，就是静态成员函数可以不通过this指针来进行调用
3.虚函数依靠vptr和vtable来处理．vptr是一个指针，在类的构造函数中创建生成,并且只能用this去当问它，因为vptr是类的成员之一，并且vptr指向保存虚函数地址的vtable
4.对于静态成员函数，没有this指针，没有办法访问vptr
虚函数的调用关系　this -> vptr - >vtable -> virtual function
• 静态成员函数，可以不通过对象来调用，即没有隐藏的this指针。
• virtual函数一定要通过对象来调用，即有隐藏的this指针。
即是说：virtual成员函数的关键是动态类型绑定的实例调用。然而，静态函数和任何类的实例都不相关，它是class的属性。

析构函数必须是虚函数？

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

为什么C++默认的析构函数不是虚函数 ?

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

析构函数的作用：

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

构造函数可以调用虚函数吗？

不能。
这个问题来自于《Effective C++》条款9：永远不要在构造函数或析构函数中调用虚函数 。

简要结论： 
１. 从语法上讲，调用完全没有问题。 
２. 但是从效果上看，往往不能达到需要的目的。 
Effective 的解释是： 
派生类对象构造期间进入基类的构造函数时，对象类型变成了基类类型，而不是派生类类型。 
同样，进入基类析构函数时，对象也是基类类型。

原因分析：
（1）不要在构造函数中调用虚函数的原因:因为父类对象会在子类之前进行构造，此时子类部分的数据成员还未初始化， 因此调用子类的虚函数是不安全的，故而C++不会进行动态联编。
（2）不要在析构函数中调用虚函数的原因:析构函数是用来销毁一个对象的，在销毁一个对象时，先调用子类的析构函数，然后再调用基类的析构函数。所以在调用基类的析构函数时，派生类对象的数据成员已经“销毁”，这个时再调用子类的虚函数已经没有意义了。

• a) 如果有继承，构造函数会先调用父类构造函数，而如果构造函数中有虚函数，此时子类还没有构造，所以此时的对象还是父类的，不会触发多态。更容易记的是基类构造期间，virtual函数不是virtual函数。
• b) 析构函数也是一样，子类先进行析构，这时，如果有virtual函数的话，子类的内容已经被析构了，C++会视其父类，执行父类的virtual函数。
• c) 总之，在构造和析构函数中，不要用虚函数。如果必须用，那么分离出一个Init函数和一个close函数，实现相关功能即可

深拷贝和浅拷贝区别：

1、浅拷贝：默认的拷贝就是浅拷贝。 仅仅多了个指针指向原来的空间，并没申请内存空间。
2、深拷贝：自己写的拷贝，自己申请了动态内存空间，用了new 或 malloc 。不但多了指针，而且多了空间。
3、用深拷贝的话，最好用自己写的析构，记得在里面释放内存，也可以用默认析构。
4.用浅拷贝（即默认隐藏的拷贝），最好用默认析构，若用自己写的析构里面 ，记得不要释放内存，不然会造成重复释放内存而报错。
5、在未定义显示拷贝构造函数的情况下，系统会调用默认的拷贝函数——即浅拷贝，它能够完成成员的一一复制。
6、当数据成员中没有指针时，浅拷贝是可行的。但当数据成员中有指针时，如果采用简单的浅拷贝，则两类中的两个指针将指向同一个地址，当对象快结束时，会调用两次析构函数，而导致指针悬挂现象。所以，这时，必须采用深拷贝。
7、深拷贝与浅拷贝的区别就在于深拷贝会在堆内存中另外申请空间来储存数据，从而也就解决了指针悬挂的问题。
简而言之，当数据成员中有指针时，必须要用深拷贝。

C++头文件包含顺序问题

C++中类的声明和类的定义分开几乎成了一个不成文的规定。这样做的好处是使得类的声明和实现分开，清晰明了，同时便于库函数发布。但是在实际编程中由此也常常引起了一些由于头文件的包含顺序问题而产生的符号未定义的编译错误，不明白其中原理有时会让人很头疼。要消除符号未定义的错误的编译错误，最基本的一个做法就是在引用一个符号（包括变量，函数，结构，类等）之前确保它已经声明或者已经定义。
实际中编码设计过程中，最基本的一个原则就是在类的头文件中最好不要包含其他头文件，因为这样会使类之间的文件包含关系变得复杂化。要最大限度的遵守这个原则，实际编码设计过程可以采用以下两种方法：

方法一是在设计一个类的时候尽量保持类的独立性，即使该类尽可能不要依赖其他类库或者函数库，或者退一步来说，尽量不要在类的声明中依赖其他类。这样，在该类的声明头文件中就可以没有其他头文件。如果实现中用到了其他的类，那么可以只在该类的实现文件中包含用到的类库或者函数库的头文件就行。

方法二是当类的声明中必须得用到其他类库或者函数库时，方法一便不再适用，当一个类声明中引用的是其他类或结构的指针引用或者是函数引用时，也可以保持上述原则，做法是采用前向引用，即在该类的声明前面先声明一下该类所用到的类名或者函数名就行。当类声明中引用的是其他类的实例时，上述原则变不能保持，只有在该类的声明头文件中引用所引用的类库或者函数库的头文件。
然而，实际中，如果一个类要用到很多其他的类指针或者结构指针或者函数名时，虽然采用上述方法二可以保持上述原则，但是在该类的前面将所有用到的类和方法声明一遍会比较麻烦，这种情况下，为了方便也只好在该类的声明头文件中加入其他类库或者函数库中的头文件了。

下面举几个例子：
例子1：最简单的一种情况：两个类A和B之间完全没有关系
这种情况下两个类的声明和定义文件中根本不需要包含对方的声明头文件。（虽然是废话，但是很多人的代码中却大量存在这种情况下仍然互相包含或者包含头文件的情况，主要原因：懒，不想多思考）

例子2：两个类A和B在实现的时候用到了对方
这种情况只需要在每个类的实现文件文件中包含所用到的类的头文件即可。

例子3：两个类A和B在声明的时候通过指针引用到了对方
这种情况下可以在类的声明（头文件中）前面声明一下所用到的类，然后在各自的头文件中包含所用的类的声明头文件。比如：

// A.h
class   B;    
  class   A    
  {    
          B   *pb;    
  }

// B.h   
  class   A;    
  class   B    
  {    
          A   *pa;    
  }

// A.cpp
#inclue "B.h"
#inclue "A.H"
......

// B.cpp
#inclue "A.h"
#inclue "B.h"
......

还有，在VC++程序设计中，一个类往往需要用到很多已有的类库及函数库，把一个类所用到的所有类库头文件都加入到类的定义头文件中往往也非常麻烦，这时的做法是把那些经常用到的头文件加入到一个公共的头文件中，这个公共头文件在VC++中是stdafx.h。要注意的是VC++中的一些头文件也有依赖关系，这些文件的包含顺序也小心，否则就会出错。
顺便提一句，VC++中的PCH(Precompiled Header File)主要目的是为了加快编译速度，预编译头文件中包括了stdafx.h文件

override, overload, overwrite：

1.overload（重载），即函数重载：
①在同一个类中；
②函数名字相同；
③函数参数不同（类型不同、数量不同，两者满足其一即可）；
④不以返回值类型不同作为函数重载的条件。
2.override（覆盖，子类改写父类的虚函数），用于实现C++中多态：
①分别位于父类和子类中；
②子类改写父类中的virtual方法；
③与父类中的函数名相同，参数也相同。
3.overwrite（重写或叫隐藏，子类改写父类的非虚函数，从而屏蔽父类函数）：
①与overload类似，但是范围不同，是子类改写父类；
②与override类似，但是父类中的方法不是虚函数。
是指派生类的函数屏蔽了与其同名的基类函数，规则如下：
（_1_）如果派生类的函数与基类的函数同名，但是参数不同。此时，不论基类有无_virtual_关键字，基类的函数将被隐藏。
（_2_）如果派生类的函数与基类的函数同名，并且参数也相同，但是基类函数没有_virtual_关键字。此时，基类的函数被隐藏（注意别与覆盖混淆)
代码示例：

#include <iostream>
using namespace std;
class A
{
public:
    virtual void show1(){    
        cout<<"A1"<<endl;
    }
      void show2() {   
        cout<<"A2"<<endl;
    }
    virtual void show3(){    
        cout<<"A3"<<endl;
    }
};

class B:public A{
public:
    void show1() {   
        cout<<"B1"<<endl;
    }
     void show2(){    
        cout<<"B2"<<endl;
    }
     void show3(int n){    
        cout<<"B3"<<endl;
    }
};

int main()
{
  A *a=new B;
  a->show1();//输出B1，多态（覆盖）
  a->show2();//输出A2，（重写）
  a->show3();//输出A3（重写，也不实现多态）
  return 0;
}

导致程序崩溃的错误有哪些：

1.函数栈溢出：一个变量未初化、未赋值，就读取它的值。
（1）定义了一个体积太大的局部变量 （2）函数嵌套调用，层次过深（如无穷递归）
2.数组越界访问：访问数组元素时，下标越界
3.指针的目标对象不可用
（1）空指针（2）野指针
野指针就是指向一个已删除的对象或者未申请访问受限内存区域的指针

段错误以调试方式

段错误通常发生在访问非法内存地址的时候，具体来说分为以下几种情况：
使用野指针
试图修改字符串常量的内容
产生段错误就是访问了错误的内存段，一般是你没有权限，或者根本就不存在对应的物理内存，尤其常见的是访问0地址。

在编程中以下几类做法容易导致段错误，基本是是错误地使用指针引起的：
1)访问系统数据区，尤其是往系统保护的内存地址写数据，最常见的就是给一个指针以0地址；
2)内存越界(数组越界，变量类型不一致等) 访问到不属于你的内存区域。
另外，缓存溢出也可能引起“段错误”，对于这种while(1) {do}的程序，这个问题最容易发生，多此sprintf或着strcat有可能将某个buff填满，溢出，所以每次使用前，最好memset一下，不过要是一开始就是段错误，而不是运行了一会儿出现的，缓存溢出的可能性就比较小。

写程序好多年了，Segment fault 是许多C程序员头疼的提示。指针是好东西，但是随着指针的使用却诞生了这个同样威力巨大的恶魔。

Segment fault 之所以能够流行于世，是与Glibc库中基本所有的函数都默认型参指针为非空有着密切关系的。
不知道什么时候才可以有能够处理NULL的glibc库诞生啊！

不得已，我现在为好多的函数做了衣服，避免glibc的函数被NULL给感染，导致我的Mem访问错误，而我还不知道NULL这个病毒已经在侵蚀我的身体了。

Segment fault 永远的痛......

限制对象只能建立在堆上或者栈上：

在C++中，类的对象建立分为两种，一种是静态建立，如A a；另一种是动态建立，如A* ptr=new A；这两种方式是有区别的。
静态建立一个类对象，是由编译器为对象在栈空间中分配内存，是通过直接移动栈顶指针，挪出适当的空间，然后在这片内存空间上调用构造函数形成一个栈对象。使用这种方法，直接调用类的构造函数。
动态建立类对象，是使用new运算符将对象建立在堆空间中。这个过程分为两步，第一步是执行operator new()函数，在堆空间中搜索合适的内存并进行分配；第二步是调用构造函数构造对象，初始化这片内存空间。这种方法，间接调用类的构造函数。
1.只能建立在堆上
对象只能建立在堆上，就是不能静态建立类对象，即不能直接调用类的构造函数。
容易想到将构造函数设为私有。在构造函数私有之后，无法在类外部调用构造函数来构造类对象，只能使用new运算符来建立对象。然而，前面已经说过，new运算符的执行过程分为两步，C++提供new运算符的重载，其实是只允许重载operator new()函数，而operator()函数用于分配内存，无法提供构造功能。因此，这种方法不可以。
当对象建立在栈上面时，是由编译器分配内存空间的，调用构造函数来构造栈对象。当对象使用完后，编译器会调用析构函数来释放栈对象所占的空间。编译器管理了对象的整个生命周期。如果编译器无法调用类的析构函数，情况会是怎样的呢？比如，类的析构函数是私有的，编译器无法调用析构函数来释放内存。所以，编译器在为类对象分配栈空间时，会先检查类的析构函数的访问性，其实不光是析构函数，只要是非静态的函数，编译器都会进行检查。如果类的析构函数是私有的，则编译器不会在栈空间上为类对象分配内存。
因此，将析构函数设为私有，类对象就无法建立在栈上，只能建立在堆上了。代码如下：

class A
{
public:
    A(){}
    void destory(){delete this;}
private:
    ~A(){}
};

试着使用A a;来建立对象，编译报错，提示析构函数无法访问。这样就只能使用new操作符来建立对象，构造函数是公有的，可以直接调用。类中必须提供一个destory函数，来进行内存空间的释放。类对象使用完成后，必须调用destory函数
上述方法的一个缺点就是，无法解决继承问题。如果A作为其它类的基类，则析构函数通常要设为virtual，然后在子类重写，以实现多态。因此析构函数不能设为private。还好C++提供了第三种访问控制，protected。将析构函数设为protected可以有效解决这个问题，类外无法访问protected成员，子类则可以访问。
另一个问题是，类的使用很不方便，使用new建立对象，却使用destory函数释放对象，而不是使用delete。（使用delete会报错，因为delete对象的指针，会调用对象的析构函数，而析构函数类外不可访问）这种使用方式比较怪异。为了统一，可以将构造函数设为protected，然后提供一个public的static函数来完成构造，这样不使用new，而是使用一个函数来构造，使用一个函数来析构。代码如下，类似于单例模式：

class A
{
protected:
    A(){}
    ~A(){}
public:
    static A* create()
    {
        return new A();
    }
    void destory()
    {
        delete this;
    }
};

　　这样，调用create()函数在堆上创建类A对象，调用destory()函数释放内存。
2.只能建立在栈上
只有使用new运算符，对象才会建立在堆上，因此，只要禁用new运算符就可以实现类对象只能建立在栈上。将operator new()设为私有即可。代码如下：

class A
{
private:
    void* operator new(size_t t){} // 注意函数的第一个参数和返回值都是固定的
    void operator delete(void* ptr){} // 重载了new就需要重载delete
public:
    A(){}
    ~A(){}
};

C语言中，先定义的语句反而后执行，出现这种情况的原因会是什么？

我觉得主要是因为C语言中变量是要占据内存空间的
就是为了在内存的相应地址中开辟一个这个变量专用的空间，也是为了计算机在使用这个变量的时候可以方便地找到这个变量在内存中所在的位置，以便于下一步的操作。
通俗点讲就是：给每个变量一个存储的位置，方便操作。

凡未被事先定义的，不作为变量名，这样能保证程序中变量名使用正确；
每一个变量被指定一确定数据类型，在编译时就能为其分配相应的存储单元；
指定每一变量属于一个类型，这就便于在编译时，据此检查该变量所进行的运算是否合法;
如果你是编一个大的程序!定义变量可以避免你的逻辑产生混乱!从而发生错误!或者降低效率!
另外以便你完善你的程序!修改和续编!!!

C++为什么要规定对所有用到的变量要先定义后使用，这样做有什么好处

规定“所有用到的变量要先定义后使用”，编译器处理起来比较方便，不会有歧义。
因为 C++ 里面，相同名字的变量在【不同的作用域】里面，是可以重复声明的。
注：每一对"{}"就是一个作用域。
比如函数里面的变量，必须要先定义了，编译器才能为你分配足够的栈空间存放这些变量以备后续使用。

如何控制 vector 的内存分配：

1.vector的内存增长：
vector其中一个特点：内存空间只会增长，不会减小，援引C++ Primer：为了支持快速的随机访问，vector容器的元素以连续方式存放，每一个元素都紧挨着前一个元素存储。设想一下，当vector添加一个元素时，为了满足连续存放这个特性，都需要重新分配空间、拷贝元素、撤销旧空间，这样性能难以接受。因此STL实现者在对vector进行内存分配时，其实际分配的容量要比当前所需的空间多一些。就是说，vector容器预留了一些额外的存储区，用于存放新添加的元素，这样就不必为每个新元素重新分配整个容器的内存空间。
在调用push_back时，每次执行push_back操作，相当于底层的数组实现要重新分配大小；这种实现体现到vector上，就是每当push_back一个元素，都要重新分配一个大一个元素的存储（一般是2倍），然后将原来的元素拷贝到新的存储，之后在拷贝push_back的元素，最后要析构原有的vector并释放原有的内存
2.vector的内存释放：
由于vector的内存占用空间只增不减，比如你首先分配了10,000个字节，然后erase掉后面9,999个，留下一个有效元素，但是内存占用仍为10,000个。所有内存空间是在vector析构时候才能被系统回收。empty()用来检测容器是否为空的，clear()可以清空所有元素。但是即使clear()，vector所占用的内存空间依然如故，无法保证内存的回收。
如果需要空间动态缩小，可以考虑使用deque。如果vector，可以用swap()来帮助你释放内存。具体方法如下：
vector<Point>().swap(pointVec); //或者pointVec.swap(vector<Point> ())
标准模板：

template < class T >
void ClearVector( vector< T >& vt ) 
{
    vector< T > vtTemp; 
    veTemp.swap( vt );
}

swap()是交换函数，使vector离开其自身的作用域，从而强制释放vector所占的内存空间，总而言之，释放vector内存最简单的方法是vector<Point>().swap(pointVec)。但是如果pointVec是一个类的成员，不能把vector<Point>().swap(pointVec)写进类的析构函数中，否则会导致double free or corruption (fasttop)的错误，原因可能是重复释放内存。(前面的pointVec.swap(vector<Point> ())用G++编译没有通过)
3.其他情况释放内存：
如果vector中存放的是指针，那么当vector销毁时，这些指针指向的对象不会被销毁，那么内存就不会被释放。如下面这种情况，vector中的元素时由new操作动态申请出来的对象指针：

#include <vector> 
using namespace std;      
vector<void *> v;
每次new之后调用v.push_back()该指针，在程序退出或者根据需要，用以下代码进行内存的释放：
for (vector<void *>::iterator it = v.begin(); it != v.end(); it ++) 
    if (NULL != *it) 
    {
        delete *it; 
        *it = NULL;
    }
v.clear();

如何让类不能被继承？

C++11提供了final关键字,可以用于修饰类,读者朋友可以自行搜索final的用法
总结:
最好使用final关键字实现目的,虚继承实现的方式是以性能为代价的
new operator new placement new：
new：
new operator就是new操作符，不能被重载，假如A是一个类，那么A * a=new A;实际上执行如下3个过程。
（1）调用operator new分配内存，operator new (sizeof(A))
（2）调用构造函数生成类对象，A::A()
（3）返回相应指针
事实上，分配内存这一操作就是由operator new(size_t)来完成的，如果类A重载了operator new，那么将调用A::operator new(size_t )，否则调用全局::operator new(size_t )，后者由C++默认提供。
operator new：
operator new是函数，分为三种形式（前2种不调用构造函数，这点区别于new operator）：
void* operator new (std::size_t size) throw (std::bad_alloc);
void* operator new (std::size_t size, const std::nothrow_t& nothrow_constant) throw();
void operator new (std::size_t size, void ptr) throw();
第一种分配size个字节的存储空间，并将对象类型进行内存对齐。如果成功，返回一个非空的指针指向首地址。失败抛出bad_alloc异常。
第二种在分配失败时不抛出异常，它返回一个NULL指针。
第三种是placement new版本，它本质上是对operator new的重载，定义于#include <new>中。它不分配内存，调用合适的构造函数在ptr所指的地方构造一个对象，之后返回实参指针ptr。
第一、第二个版本可以被用户重载，定义自己的版本，第三种placement new不可重载。
A* a = new A; //调用第一种
A* a = new(std::nothrow) A; //调用第二种
new (p)A(); //调用第三种
new (p)A()调用placement new之后，还会在p上调用A::A()，这里的p可以是堆中动态分配的内存，也可以是栈中缓冲。
placement new：
一般来说，使用new申请空间时，是从系统的“堆”（heap）中分配空间。申请所得的空间的位置是根据当时的内存的实际使用情况决定的。但是，在某些特殊情况下，可能需要在已分配的特定内存创建对象，这就是所谓的“定位放置new”（placement new）操作。
定位放置new操作的语法形式不同于普通的new操作。例如，一般都用如下语句A p=new A;申请空间，而定位放置new操作则使用如下语句A p=new (ptr)A;申请空间，其中ptr就是程序员指定的内存首地址

hash 函数、哈希冲突的解决方法：

1.开放定址
开放地址法有个非常关键的特征，就是所有输入的元素全部存放在哈希表里，也就是说，位桶的实现是不需要任何的链表来实现的，换句话说，也就是这个哈希表的装载因子不会超过1。它的实现是在插入一个元素的时候，先通过哈希函数进行判断，若是发生哈希冲突，就以当前地址为基准，根据再寻址的方法（探查序列），去寻找下一个地址，若发生冲突再去寻找，直至找到一个为空的地址为止。所以这种方法又称为再散列法。
有几种常用的探查序列的方法：
①线性探查
dii=1，2，3，…，m-1；这种方法的特点是：冲突发生时，顺序查看表中下一单元，直到找出一个空单元或查遍全表。
②二次探查
di=12，-12，22，-22，…，k2，-k2 ( k<=m/2 )；这种方法的特点是：冲突发生时，在表的左右进行跳跃式探测，比较灵活。
③ 伪随机探测
di=伪随机数序列；具体实现时，应建立一个伪随机数发生器，（如i=(i+p) % m），生成一个位随机序列，并给定一个随机数做起点，每次去加上这个伪随机数++就可以了。
2.链地址
每个位桶实现的时候，采用链表或者树的数据结构来去存取发生哈希冲突的输入域的关键字，也就是被哈希函数映射到同一个位桶上的关键字。
紫色部分即代表哈希表，也称为哈希数组，数组的每个元素都是一个单链表的头节点，链表是用来解决冲突的，如果不同的key映射到了数组的同一位置处，就将其放入单链表中，即链接在桶后。
3.公共溢出区
建立一个公共溢出区域，把hash冲突的元素都放在该溢出区里。查找时，如果发现hash表中对应桶里存在其他元素，还需要在公共溢出区里再次进行查找。
4.再hash
再散列法其实很简单，就是再使用哈希函数去散列一个输入的时候，输出是同一个位置就再次散列，直至不发生冲突位置。
缺点：每次冲突都要重新散列，计算时间增加。

各种排序算法：

1、冒泡排序：
从数组中第一个数开始，依次遍历数组中的每一个数，通过相邻比较交换，每一轮循环下来找出剩余未排序数的中的最大数并“冒泡”至数列的顶端。
稳定性：稳定
平均时间复杂度：O(n ^ 2)
2、插入排序：
从待排序的n个记录中的第二个记录开始，依次与前面的记录比较并寻找插入的位置，每次外循环结束后，将当前的数插入到合适的位置。
稳定性：稳定
平均时间复杂度：O(n ^ 2)
3、希尔排序（缩小增量排序）：
希尔排序法是对相邻指定距离(称为增量)的元素进行比较，并不断把增量缩小至1，完成排序。
希尔排序开始时增量较大，分组较多，每组的记录数目较少，故在各组内采用直接插入排序较快，后来增量di逐渐缩小，分组数减少，各组的记录数增多，但由于已经按di−1分组排序，文件叫接近于有序状态，所以新的一趟排序过程较快。因此希尔排序在效率上比直接插入排序有较大的改进。在直接插入排序的基础上，将直接插入排序中的1全部改变成增量d即可，因为希尔排序最后一轮的增量d就为1。
稳定性：不稳定
平均时间复杂度：希尔排序算法的时间复杂度分析比较复杂，实际所需的时间取决于各次排序时增量的个数和增量的取值。时间复杂度在O(n ^ 1.3)到O(n ^ 2)之间。
4、选择排序：
从所有记录中选出最小的一个数据元素与第一个位置的记录交换；然后在剩下
的记录当中再找最小的与第二个位置的记录交换，循环到只剩下最后一个数据元素为止。
稳定性：不稳定
平均时间复杂度：O(n ^ 2)
5、快速排序：
1）从待排序的n个记录中任意选取一个记录（通常选取第一个记录）为分区标准;
2）把所有小于该排序列的记录移动到左边，把所有大于该排序码的记录移动到右边，中间放所选记录，称之为第一趟排序；
3）然后对前后两个子序列分别重复上述过程，直到所有记录都排好序。
稳定性：不稳定
平均时间复杂度：O(nlogn)
6、堆排序：
堆：
1、完全二叉树或者是近似完全二叉树。
2、大顶堆：父节点不小于子节点键值，小顶堆：父节点不大于子节点键值。左右孩子没有大小的顺序。
堆排序在选择排序的基础上提出的，步骤：
1、建立堆
2、删除堆顶元素，同时交换堆顶元素和最后一个元素，再重新调整堆结构，直至全部删除堆中元素。
稳定性：不稳定
平均时间复杂度：O(nlogn)
7、归并排序：
采用分治思想，现将序列分为一个个子序列，对子序列进行排序合并，直至整个序列有序。
稳定性：稳定
平均时间复杂度：O(nlogn)
8、计数排序：
思想：如果比元素x小的元素个数有n个，则元素x排序后位置为n+1。
步骤：
1）找出待排序的数组中最大的元素；
2）统计数组中每个值为i的元素出现的次数，存入数组C的第i项；
3）对所有的计数累加（从C中的第一个元素开始，每一项和前一项相加）；
4）反向填充目标数组：将每个元素i放在新数组的第C(i)项，每放一个元素就将C(i)减去1。
稳定性：稳定
时间复杂度：O(n+k)，k是待排序数的范围。
9、桶排序：
步骤：
1）设置一个定量的数组当作空桶子； 常见的排序算法及其复杂度：
2）寻访序列，并且把记录一个一个放到对应的桶子去；
3）对每个不是空的桶子进行排序。
4）从不是空的桶子里把项目再放回原来的序列中。
时间复杂度：O(n+C) ，C为桶内排序时间。

软连接和硬连接：

硬链接：新建的文件是已经存在的文件的一个别名，当原文件删除时，新建的文件仍然可以使用.
软链接：也称为符号链接，新建的文件以“路径”的形式来表示另一个文件，和Windows的快捷方式十分相似，新建的软链接可以指向不存在的文件.

1.硬链接和原来的文件没有什么区别，而且共享一个 inode 号（文件在文件系统上的唯一标识）；而软链接不共享 inode，也可以说是个特殊的 inode，所以和原来的 inode 有区别。
2.若原文件删除了，则该软连接则不可以访问，而硬连接则是可以的。
3.由于符号链接的特性，导致其可以跨越磁盘分区，但硬链接不具备这个特性.
硬链接(hard link)：
UNIX文件系统提供了一种将不同文件链接至同一个文件的机制，我们称这种机制为链接。它可以使得单个程序对同一文件使用不同的名字。这样的好处是文件系统只存在一个文件的副本。系统简单地通过在目录中建立一个新的登记项来实现这种连接。该登记项具有一个新的文件名和要连接文件的inode号(inode与原文件相同)。不论一个文件有多少硬链接，在磁盘上只有一个描述它的inode，只要该文件的链接数不为0，该文件就保持存在。硬链接不能对目录建立硬链接！
硬连接是直接建立在节点表上的（inode），建立硬连接指向一个文件的时候，会更新节点表上面的计数值。举个例子，一个文件被连接了两次（硬连接），这个 文件的计数值是3，而无论通过3个文件名中的任何一个访问，效果都是完全一样的，但是如果删除其中任意一个，都只是把计数值减1，不会删除实际的内容的，（任何存在的文件本身就算是一个硬连接）只有计数值变成0也就是没有任何硬连接指向的时候才会真实的删除内容。
软链接(symbolic link)：
我们把符号链接称为软链接，它是指向另一个文件的特殊文件，这种文件的数据部分仅包含它所要链接文件的路径名。软链接是为了克服硬链接的不足而引入的，软链接不直接使用inode号作为文件指针，而是使用文件路径名作为指针（软链接：文件名 + 数据部分-->目标文件的路径名）。软件有自己的inode，并在磁盘上有一小片空间存放路径名。因此，软链接能够跨文件系统，也可以和目录链接！其二，软链接可以对一个不存在的文件名进行链接，但直到这个名字对应的文件被创建后，才能打开其链接。

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

预处理阶段：对源代码文件中文件包含关系（头文件）、预编译语句（宏定义）进行分析和替换，生成预编译文件。
编译阶段：将经过预处理后的预编译文件转换成特定汇编代码，生成汇编文件
汇编阶段：将编译阶段生成的汇编文件转化成机器码，生成可重定位目标文件
链接阶段：将多个目标文件及所需要的库连接成最终的可执行目标文件

动态链接和静态链接：

编译：
1首先对源文件进行预处理，这个过程主要是处理一些#号定义的命令或语句（如宏、#include、预编译指令#ifdef等），生成*.i文件；
2然后进行编译，这个过程主要是进行词法分析、语法分析和语义分析等，生成*.s的汇编文件；
3最后进行汇编，这个过程比较简单，就是将对应的汇编指令翻译成机器指令，生成可重定位的二进制目标文件。
两种链接方式--静态链接和动态链接：

静态链接和动态链接两者最大的区别就在于链接的时机不一样，静态链接是在形成可执行程序前，而动态链接的进行则是在程序执行时

一、静态链接

1.为什么要进行静态链接
在我们的实际开发中，不可能将所有代码放在一个源文件中，所以会出现多个源文件，而且多个源文件之间不是独立的，而会存在多种依赖关系，如一个源文件可能要调用另一个源文件中定义的函数，但是每个源文件都是独立编译的，即每个.c文件会形成一个.o文件，为了满足前面说的依赖关系，则需要将这些源文件产生的目标文件进行链接，从而形成一个可以执行的程序。这个链接的过程就是静态链接
2.静态链接的原理
由很多目标文件进行链接形成的是静态库，反之静态库也可以简单地看成是一组目标文件的集合，即很多目标文件经过压缩打包后形成的一个文件，
我们知道，链接器在链接静态链接库的时候是以目标文件为单位的。比如我们引用了静态库中的printf()函数，那么链接器就会把库中包含printf()函数的那个目标文件链接进来，如果很多函数都放在一个目标文件中，很可能很多没用的函数都被一起链接进了输出结果中。由于运行库有成百上千个函数，数量非常庞大，每个函数独立地放在一个目标文件中可以尽量减少空间的浪费，那些没有被用到的目标文件就不要链接到最终的输出文件中。
3.静态链接的优缺点
静态链接的缺点很明显，一是浪费空间，因为每个可执行程序中对所有需要的目标文件都要有一份副本，所以如果多个程序对同一个目标文件都有依赖，如多个程序中都调用了printf()函数，则这多个程序中都含有printf.o，所以同一个目标文件都在内存存在多个副本；另一方面就是更新比较困难，因为每当库函数的代码修改了，这个时候就需要重新进行编译链接形成可执行程序。但是静态链接的优点就是，在可执行程序中已经具备了所有执行程序所需要的任何东西，在执行的时候运行速度快。

二、动态链接

1.为什么会出现动态链接
动态链接出现的原因就是为了解决静态链接中提到的两个问题，一方面是空间浪费，另外一方面是更新困难。下面介绍一下如何解决这两个问题。
2.动态链接的原理
动态链接的基本思想是把程序按照模块拆分成各个相对独立部分，在程序运行时才将它们链接在一起形成一个完整的程序，而不是像静态链接一样把所有程序模块都链接成一个单独的可执行文件。下面简单介绍动态链接的过程：
假设现在有两个程序program1.o和program2.o，这两者共用同一个库lib.o,假设首先运行程序program1，系统首先加载program1.o，当系统发现program1.o中用到了lib.o，即program1.o依赖于lib.o，那么系统接着加载lib.o，如果program1.o和lib.o还依赖于其他目标文件，则依次全部加载到内存中。当program2运行时，同样的加载program2.o，然后发现program2.o依赖于lib.o，但是此时lib.o已经存在于内存中，这个时候就不再进行重新加载，而是将内存中已经存在的lib.o映射到program2的虚拟地址空间中，从而进行链接（这个链接过程和静态链接类似）形成可执行程序。
3.动态链接的优缺点
动态链接的优点显而易见，就是即使需要每个程序都依赖同一个库，但是该库不会像静态链接那样在内存中存在多份副本，而是这多个程序在执行时共享同一份副本；另一个优点是，更新也比较方便，更新时只需要替换原来的目标文件，而无需将所有的程序再重新链接一遍。当程序下一次运行时，新版本的目标文件会被自动加载到内存并且链接起来，程序就完成了升级的目标。但是动态链接也是有缺点的，因为把链接推迟到了程序运行时，所以每次执行程序都需要进行链接，所以性能会有一定损失。

c++如何引用c文件：

步骤： 把c文件添加到项目中，点击右键属性->预编译头->不使用预编译头。
假如C文件声明在某个.h文件中，则需要把头文件添加到extern "C"中，
C++调用C函数需要extern C，因为C语言没有函数重载

extern "C"
{
#include "sift.h"
#include "imgfeatures.h"
#include "kdtree.h"
#include "utils.h"
#include "xform.h"
//...C语言函数声明或者头文件，标识用C来编译
};

迭代器是什么:

背景: 指针可以用来遍历存储空间连续的数据结构，但是对于存储空间费连续的，就需要寻找一个行为类似指针的类，来对非数组的数据结构进行遍历。
定义：迭代器是一种检查容器内元素并遍历元素的数据类型。迭代器提供对一个容器中的对象的访问方法，并且定义了容器中对象的范围。迭代器（Iterator）是指针（pointer）的泛化，它允许程序员用相同的方式处理不同的数据结构（容器）。
（1）迭代器类似于C语言里面的指针类型，它提供了对对象的间接访问。
（2）指针是C语言中的知识点，迭代器是C++中的知识点。指针较灵活，迭代器功能较丰富。
（3）迭代器提供一个对容器对象或者string对象的访问方法，并定义了容器范围。
1.迭代器和指针的区别：
容器和string有迭代器类型同时拥有返回迭代器的成员。如：容器有成员begin和end,其中begin成员复制返回指向第一个元素的迭代器，而end成员返回指向容器尾元素的下一个位置的迭代器，也就是说end指示的是一个不存在的元素，所以end返回的是尾后迭代器。
2.容器迭代器的使用：
每种容器类型都定义了自己的迭代器类型，如vector：vector< int>:: iterator iter;//定义一个名为iter的变量，数据类型是由vector< int>定义的iterator 类型。简单说就是容器类定义了自己的iterator类型，用于访问容器内的元素。每个容器定义了一种名为iterator的类型，这种类型支持迭代器的各种行为。
常用迭代器类型如下：

如上图所示，迭代器类型主要支持两类，随机访问和双向访问。其中vector和deque支持随机访问，list,set,map等支持双向访问。
1）随机访问：提供了对数组元素进行快速随机访问以及在序列尾部进行快速插入和删除操作。
2）双向访问：插入和删除所花费的时间是固定的，与位置无关。

1. 迭代器的操作

1、所有迭代器：

2、双向迭代器：

3、输入迭代器：

4、输出迭代器

5、随机迭代器

STL迭代器是怎么删除元素的呢?（迭代器失效）

这个主要考察的是迭代器失效的问题。
1.对于序列容器vector,deque来说，使用erase(itertor)后，后边的每个元素的迭代器都会失效，这是因为vetor,deque使用了连续分配的内存，删除一个元素导致后面所有的元素会向前移动一个位置。所以不能使用erase(iter++)的方式，还好erase方法可以返回下一个有效的iterator。
所以为了防止vector迭代器失效，常用如下方法：

for (iter = container.begin(); iter != container.end(); ) { 
             iter = container.erase(iter);    
             //erase的返回值是删除元素下一个元素的迭代器
  
else{ 
                 iter++; 
    } 
 }

这样删除后iter指向的元素后，返回的是下一个元素的迭代器，这个迭代器是vector内存调整过后新的有效的迭代器。
2.对于关联容器(如map, set,multimap,multiset)，删除当前的iterator，仅仅会使当前的iterator失效，只要在erase时，递增当前iterator即可。这是因为map之类的容器，使用了红黑树来实现，插入、删除一个结点不会对其他结点造成影响。erase迭代器只是被删元素的迭代器失效，但是返回值为void，所以要采用erase(iter++)的方式删除迭代器。
所以在map中为了防止迭代器失效，在有删除操作时，常用如下方法：

for (iter = dataMap.begin(); iter != dataMap.end(); )
{
     int nKey = iter->first;
     string strValue = iter->second;

     if (nKey % 2 == 0)
     {
          map<int, string>::iterator tmpIter = iter;
          iter++;
          dataMap.erase(tmpIter);
          //dataMap.erase(iter++) 这样也行

     }else{     
      iter++;
     }
}

3.对于链表式容器(如list)，删除当前的iterator，仅仅会使当前的iterator失效，这是因为list之类的容器，使用了链表来实现，插入、删除一个结点不会对其他结点造成影响。只要在erase时，递增当前iterator即可，并且erase方法可以返回下一个有效的iterator。上面两种方法都可以使用。
方式一:递增当前iterator：

for (iter = cont.begin(); it != cont.end();)
{
   (*iter)->doSomething();
   if (shouldDelete(*iter))
      cont.erase(iter++);
   else
      ++iter;
}

方式二:通过erase获得下一个有效的iterator：

for (iter = cont.begin(); iter != cont.end();)
{
   (*it)->doSomething();
   if (shouldDelete(*iter))
      iter = cont.erase(iter);  //erase删除元素，返回下一个迭代器
   else
      ++iter;
}

总结:

迭代器失效分三种情况考虑，也是分三种数据结构考虑，分别为数组型，链表型，树型数据结构。

数组型数据结构：该数据结构的元素是分配在连续的内存中，insert和erase操作，都会使得删除点和插入点之后的元素挪位置，所以，插入点和删除掉之后的迭代器全部失效，也就是说insert(\iter)(或erase(\iter))，然后在iter++，是没有意义的。解决方法：erase(\*iter)的返回值是下一个有效迭代器的值。 iter =cont.erase(iter);

链表型数据结构：对于list型的数据结构，使用了不连续分配的内存，删除运算使指向删除位置的迭代器失效，但是不会失效其他迭代器.解决办法两种，erase(\*iter)会返回下一个有效迭代器的值，或者erase(iter++).

树形数据结构： 使用红黑树来存储数据，插入不会使得任何迭代器失效；删除运算使指向删除位置的迭代器失效，但是不会失效其他迭代器.erase迭代器只是被删元素的迭代器失效，但是返回值为void，所以要采用erase(iter++)的方式删除迭代器。

注意：经过erase(iter)之后的迭代器完全失效，该迭代器iter不能参与任何运算，包括iter++,\*iter

类（class）和结构体（sturct）：

1、在C++中，可以用struct和class定义类，都可以继承。区别在于：struct的默认继承权限和默认访问权限是public，而class的默认继承权限和默认访问权限是private。
2、class还可以定义模板类形参，比如template <class T, int i>。
3、sturct是一种值类型，而class是引用类型。区别在于复制方式，值类型的数据是值赋值，引用类型的数据是引用复制。
4、sturct使用栈存储（Stack Allocation），栈的空间相对较小. 但是存储在栈中的数据访问效率相对较高。而class使用堆存储（Heap Allocation)，堆的空间相对较大.但是存储在堆中的数据的访问效率相对较低。
5、sturct使用完之后就自动解除内存分配，class实例有垃圾回收机制来保证内存的回收处理
如何选择结构体还是类：
1． 堆栈的空间有限，对于大量的逻辑的对象，创建类要比创建结构好一些
2． 结构体表示如点、矩形和颜色这样的轻量对象，例如，如果声明一个含有 1000 个点对象的数组，则将为引用每个对象分配附加的内存。在此情况下，结构体的成本较低。
3． 在表现抽象和多级别的对象层次时，类是最好的选择，因为结构体不支持继承
4． 大多数情况下该类型只是一些数据时，结构体时最佳的选择

数据进行序列化和反序列化：

序列化：将对象变成字节流的形式传出去。
反序列化：从字节流恢复成原来的对象。

智能指针：

为什么要使用智能指针：
由于 C++ 语言没有自动内存回收机制，程序员每次 new 出来的内存都要手动 delete，比如流程太复杂，最终导致没有 delete，异常导致程序过早退出，没有执行 delete 的情况并不罕见，并造成内存泄露。如此c++引入智能指针 ，智能指针即是C++ RAII的一种应用，可用于动态资源管理，资源即对象的管理策略。 智能指针在 <memory> 标头文件的 std 命名空间中定义。 它们对 RAII 或获取资源即初始化编程惯用法至关重要。RAII 的主要原则是为所有堆分配资源提供所有权，例如动态分配内存或系统对象句柄、析构函数包含要删除或释放资源的代码的堆栈分配对象，以及任何相关清理代码。所以智能指针的作用原理就是在函数结束时自动释放内存空间，不需要手动释放内存空间。

1、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的缺点是：存在潜在的内存崩溃问题！

2、unique_ptr（替换auto_ptr）
只允许基础指针的一个所有者。 可以移到新所有者(具有移动语义)，但不会复制或共享（即我们无法得到指向同一个对象的两个unique\_ptr）。 替换已弃用的 auto\_ptr。 相较于 boost::scoped\_ptr。 unique\_ptr 小巧高效；大小等同于一个指针，支持 rvalue 引用，从而可实现快速插入和对 STL 集合的检索。 头文件：<memory>。
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;

使用unique\_ptr，可以实现以下功能：

1、为动态申请的内存提供异常安全。
2、将动态申请内存的所有权传递给某个函数。
3、从某个函数返回动态申请内存的所有权。
4、在容器中保存指针。
5、所有auto\_ptr应该具有的（但无法在C++ 03中实现的）功能。
如下代码所示：

class A;
// 如果程序执行过程中抛出了异常，unique_ptr就会释放它所指向的对象
// 传统的new 则不行
unique_ptr<A> fun1(){    
unique_ptr p(new A);   
//do something    
return p;
} 
void fun2(){  
//  unique_ptr具有移动语义  
unique_ptr<A> p = f();
// 使用移动构造函数   
// do something
} // 在函数退出的时候，p以及它所指向的对象都被删除释放

3、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<int> sp(new int(1)); sp 与 sp.get()是等价的
采用引用计数的智能指针。 shared\_ptr基于“引用计数”模型实现，多个shared\_ptr可指向同一个动态对象，并维护了一个共享的引用计数器，记录了引用同一对象的shared\_ptr实例的数量。当最后一个指向动态对象的shared\_ptr销毁时，会自动销毁其所指对象(通过delete操作符)。shared\_ptr的默认能力是管理动态内存，但支持自定义的Deleter以实现个性化的资源释放动作。头文件：<memory>。

基本操作：shared\_ptr的创建、拷贝、绑定对象的变更(reset)、shared\_ptr的销毁(手动赋值为nullptr或离开作用域)、指定deleter等操作。
 shared\_ptr的创建,有两种方式，一，使用函数make\_shared(会根据传递的参数调用动态对象的构造函数)；二，使用构造函数(可从原生指针、unique\_ptr、另一个shared\_ptr创建)

    shared_ptr<int> p1 = make_shared<int>(1);// 通过make_shared函数    
    shared_ptr<int> p2(new int(2));// 通过原生指针构造

此外智能指针若为“空“，即不指向任何对象，则为false，否则为true，可作为条件判断。可以通过两种方式指定deleter，一是构造shared\_ptr时，二是使用reset方法时。可以重载的operator->, operator \*，以及其他辅助操作如unique()、use\_count(), get()等成员方法。
4、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。

结合 shared\_ptr 使用的特例智能指针。 weak\_ptr 提供对一个或多个 shared\_ptr 实例所属对象的访问，但是，不参与引用计数。 如果您想要观察对象但不需要其保持活动状态，请使用该实例。 在某些情况下需要断开 shared\_ptr 实例间的循环引用。 头文件：<memory>。
weak\_ptr的用法如下：
weak\_ptr用于配合shared\_ptr使用，并不影响动态对象的生命周期，即其存在与否并不影响对象的引用计数器。weak\_ptr并没有重载operator->和operator \*操作符，因此不可直接通过weak\_ptr使用对象。提供了expired()与lock()成员函数，前者用于判断weak\_ptr指向的对象是否已被销毁，后者返回其所指对象的shared\_ptr智能指针(对象销毁时返回”空“shared\_ptr)。循环引用的场景：如二叉树中父节点与子节点的循环引用，容器与元素之间的循环引用等。

智能指针的循环引用

循环引用问题可以参考这个链接上的问题理解，“循环引用”简单来说就是：两个对象互相使用一个shared\_ptr成员变量指向对方的会造成循环引用。导致引用计数失效。下面给段代码来说明循环引用：

#include <iostream>
#include <memory>
using namespace std; 
class B;
class A{
public:// 为了省去一些步骤这里 数据成员也声明为public    //weak_ptr<B> pb;   
shared_ptr<B> pb;    
void doSomthing()    {
//if(pb.lock())
// {    
//
// }
}     
~A()    
{        
cout << "kill A\n";    
}
};
class B
{
public:    
//weak_ptr<A> pa;    
shared_ptr<A> pa;    
~B()    
{        
cout <<"kill B\n";    
}
}; 
int main(int argc, char** argv){   
shared_ptr<A> sa(new A());    
shared_ptr<B> sb(new B());    
if(sa && sb)    
{        
sa->pb=sb;        
sb->pa=sa;    
}    
cout<<"sa use count:"<<sa.use_count()<<endl;    
return 0;}

上面的代码运行结果为：sa use count:2， 注意此时sa,sb都没有释放，产生了内存泄露问题！！！

即A内部有指向B，B内部有指向A，这样对于A，B必定是在A析构后B才析构，对于B，A必定是在B析构后才析构A，这就是循环引用问题，违反常规，导致内存泄露。

一般来讲，解除这种循环引用有下面有三种可行的方法(参考)：
1. 当只剩下最后一个引用的时候需要手动打破循环引用释放对象。
2. 当A的生存期超过B的生存期的时候，B改为使用一个普通指针指向A。
3. 使用弱引用的智能指针打破这种循环引用。
虽然这三种方法都可行，但方法1和方法2都需要程序员手动控制，麻烦且容易出错。我们一般使用第三种方法：弱引用的智能指针weak\_ptr。

强引用和弱引用
一个强引用当被引用的对象活着的话，这个引用也存在（就是说，当至少有一个强引用，那么这个对象就不能被释放）。share\_ptr就是强引用。相对而言，弱引用当引用的对象活着的时候不一定存在。仅仅是当它存在的时候的一个引用。弱引用并不修改该对象的引用计数，这意味这弱引用它并不对对象的内存进行管理，在功能上类似于普通指针，然而一个比较大的区别是，弱引用能检测到所管理的对象是否已经被释放，从而避免访问非法内存。

使用weak\_ptr来打破循环引用

代码如下：

#include <iostream>
#include <memory>
using namespace std; 
class B;
class A{
public:// 为了省去一些步骤这里 数据成员也声明为public    weak_ptr<B> pb;    //shared_ptr<B> pb;    
void doSomthing()    
{        
shared_ptr<B> pp = pb.lock();        
if(pp)//通过lock()方法来判断它所管理的资源是否被释放       
{            
cout<<"sb use count:"<<pp.use_count()<<endl;        
}    
}     
~A()    
{        
cout << "kill A\n";    }
}; 
class B{
public:    
//weak_ptr<A> pa;    
shared_ptr<A> pa;    
~B()    
{        
cout <<"kill B\n";    }
}; 
int main(int argc, char** argv){    
shared_ptr<A> sa(new A());    
shared_ptr<B> sb(new B());    
if(sa && sb)    {        
sa->pb=sb;        
sb->pa=sa;    }    
sa->doSomthing();    
cout<<"sb use count:"<<sb.use_count()<<endl;   
return 0;}

需要知道的：

weak\_ptr除了对所管理对象的基本访问功能（通过get()函数）外，还有两个常用的功能函数：expired()用于检测所管理的对象是否已经释放；lock()用于获取所管理的对象的强引用指针。不能直接通过weak\_ptr来访问资源。那么如何通过weak\_ptr来间接访问资源呢？答案是：在需要访问资源的时候weak\_ptr为你生成一个shared\_ptr，shared\_ptr能够保证在shared\_ptr没有被释放之前，其所管理的资源是不会被释放的。创建shared\_ptr的方法就是lock()方法。

B树和B+树的区别：

这都是由于B+树和B具有这不同的存储结构所造成的区别，以一个m阶树为例。
1.关键字的数量不同：B+树中分支结点有m个关键字，其叶子结点也有m个，其关键字只是起到了一个索引的作用，但是B树虽然也有m个子结点，但是其只拥有m-1个关键字。
2.存储的位置不同：B+树中的数据都存储在叶子结点上，也就是其所有叶子结点的数据组合起来就是完整的数据，但是B树的数据存储在每一个结点中，并不仅仅存储在叶子结点上。
3.分支结点的构造不同：B+树的分支结点仅仅存储着关键字信息和儿子的指针（这里的指针指的是磁盘块的偏移量），也就是说内部结点仅仅包含着索引信息。
4.查询不同：B树在找到具体的数值以后，则结束，而B+树则需要通过索引找到叶子结点中的数据才结束，也就是说B+树的搜索过程中走了一条从根结点到叶子结点的路径。
B树：二叉树，每个结点只存储一个关键字，等于则命中，小于走左结点，大于
走右结点；
B-树：多路搜索树，每个结点存储M/2到M个关键字，非叶子结点存储指向关键
字范围的子结点；所有关键字在整颗树中出现，且只出现一次，非叶子结点可以命中；
B+树：在B-树基础上，为叶子结点增加链表指针，所有关键字都在叶子结点
中出现，非叶子结点作为叶子结点的索引；B+树总是到叶子结点才命中；
B*树：在B+树基础上，为非叶子结点也增加链表指针，将结点的最低利用率
从1/2提高到2/3；

红黑树是什么原理，为什么搜索比较快

红黑树属于平衡二叉树。它不严格是因为它不是严格控制左、右子树高度或节点数之差小于等于1，但红黑树高度依然是平均log(n)，且最坏情况高度不会超过2log(n)。
红黑树(red-black tree) 是一棵满足下述性质的二叉查找树：

1. 每一个结点要么是红色，要么是黑色。
2. 根结点是黑色的。
3. 所有叶子结点都是黑色的（实际上都是Null指针，下图用NIL表示）。叶子结点不包含任何关键字信息，所有查询关键字都在非终结点上。
4. 每个红色结点的两个子节点必须是黑色的。换句话说：从每个叶子到根的所有路径上不能有两个连续的红色结点
5. 从任一结点到其每个叶子的所有路径都包含相同数目的黑色结点

红黑树相关定理

1. 从根到叶子的最长的可能路径不多于最短的可能路径的两倍长。
2. 红黑树的树高(h)不大于两倍的红黑树的黑深度(bd)，即h<=2bd
3. 一棵拥有n个内部结点(不包括叶子结点)的红黑树的树高h<=2log(n+1)
   从这里我们能够看出，红黑树的查找长度最多不超过2log(n+1)，因此其查找时间复杂度也是O(log N)级别的。

红黑树的操作
因为每一个红黑树也是一个特化的二叉查找树，因此红黑树上的查找操作与普通二叉查找树上的查找操作相同。然而，在红黑树上进行插入操作和删除操作会导致不 再符合红黑树的性质。恢复红黑树的属性需要少量(O(log n))的颜色变更(实际是非常快速的)和不超过三次树旋转(对于插入操作是两次)。 虽然插入和删除很复杂，但操作时间仍可以保持为 O(log n) 次 。

红黑树的优势
红黑树能够以O(log2(N))的时间复杂度进行搜索、插入、删除操作。此外,任何不平衡都会在3次旋转之内解决。这一点是AVL所不具备的。

而且实际应用中，很多语言都实现了红黑树的数据结构。比如 TreeMap, TreeSet(Java )、 STL(C++)等。

内存对齐的用途和方式

内存对齐
内存对齐
内存对齐的主要作用是：
1、  平台原因/移植原因不是所有的硬件平台都能访问任意地址上的任意数据的；某些硬件平台只能在某些地址处取某些特定类型的数据，否则抛出硬件异常。
2、  性能原因经过内存对齐后，CPU的内存访问速度大大提升。具体原因稍后解释。

C++何时调用构造函数，何时调用析构函数

1) 指针不会调用构造和析构函数：
C++中如果声明一个对象指针时没有分配内存，那么不会调用构造函数
一个指针在内存中也是有内存空间的。
在现在大多数机器上指针都是32位的，也就是4个字节。
如果你声明指针。例如，假设A是一个类
A *pa;
这内存中会分配4个字节的空间存储一个地址。只不过地址是不可以用的，因为它没有有效的指向某一个有用的内存空间。这和你声明一个int类型是一样的。
int p;
内存中也会分配4个字节空间给p来存储一个整形值，只不过这个整形值不是可用的，或者是垃圾的。
但是对应你说的调用构造函数。其实指的是
A *pa=new A;
这个时候，就会调用A的默认构造函数。它会在内存中分配内存，别且把这个有效的内存地址存储到指针变量pa的4个字节空间中
2) 当对指针用new在内存中开辟空间的时候会调用构造函数：
3) 当我们使用new为指针开辟空间，然后用delete释放掉空间会调用构造和析构函数：
开存储空间仅仅是为按照对象的size为其申请内存。
而只有对象被实例化的时候才会调用类的构造函数。
4) 当我们函数的形参是一个对象的时候，这时候会系统只会调用析构函数，而缺少形参的构造函数：（调用拷贝构造）
当形参为一个对象的时候，实参也为对象，这时候系统会将实参复制一份给形参，此时系统就不会再给形参额外调用构造函数来对形参对象初始化了，所以就不会调用构造函数，但是形参被销毁的时候还是会调用析构函数！
5) 当我们函数的形参是一个引用的时候，这时候会系统不调用构造函数和析构函数：
当形参为一个引用的时候，实参也对象，这时候系统会将形参指向实参，此时系统就不会对形参调用构造函数和析构函数！

拷贝构造函数被调用的三种情况

1) 当用一个对象去初始化同类的另一个对象时，会引发拷贝构造函数被调用。
2) 如果函数 F 的参数是类 A 的对象，那么当 F 被调用时，类 A 的拷贝构造函数将被调用。换句话说，作为形参的对象，是用拷贝构造函数初始化的，而且调用拷贝构造函数时的参数，就是调用函数时所给的实参。
3) 如果函数的返冋值是类 A 的对象，则函数返冋时，类 A 的拷贝构造函数被调用。换言之，作为函数返回值的对象是用拷贝构造函数初始化的，而调用拷贝构造函数时的实参，就是 return 语句所返回的对象。

向一个树插入一个节点

• 插入的方式应分为两种：
  — 插入新结点：bool insert(TreeNode<T>* node)
  — 插入数据元素：bool insert(const T& value, TreeNode<T>* parent)
• 如何在树中指定新结点的位置？
  — 树是非线性的，无法采用下标的形式定位数据元素
  — 每一个树结点都有唯一的前驱结点（父结点）
  — 因此，必须先找到前驱节点，才能完成新结点的插入

数据结构树和二叉树的实际应用：

用哈夫曼编码进行通bai信可以大大du提高信道的利用率，缩短信息传输的时间，降低传输成本

①，红黑树:STLmap、set底层实现;linux中的epoll模型，nginx中的Timer管理等。

②，B，B＋树:广泛用于数据库(mysql，oracle等)的索引。

③，字典树:用于海量文本词频统计，查询效率比哈希表还高。

④，生活中的树状结构有公司职级关系，国家省市区级联，族谱等等都有树结构形式！

图的应用：

若要在n个城市之间建设通信网络，只需要假设n-1条线路即可。如何以最低的经济代价建设这个通信网，是一个网的最小生成树问题。
计算关键路径：
名词解释：生成树（所有顶点连通又不形成回路）；

          深度优先生成树；
          广度优先生成树；
          最小生成树（具有权最小的生成树）；

      算法：（1）普里姆算法（连接单向）：

           void Prim(adjmatrix GA，edgeset CT,int n){}
      （2）克鲁斯卡尔（连接多向） 
           void Kruskal(adjmatrix GA，edgeset CT,int n){}
      （3）最短路径概念（迪克斯特拉） 
           void Dijkstra(adjmatrix GA,int dist[]){} 
      （4）拓扑排序（初度为零）
           void Toposort(adjlist GL，int n){}

       关键路径：

      AOV网（有向带权图）-{顶点代表“事件”；权代表“持续的时间”}；
      最早发生时间（它的所有入边活动完成的时间）；
      最早开始时间（它的起点事件的最早发生时间）；
      最早发生时间应等于从源点到该顶点的所有路径上的最长路径长度；
      最迟发生时间应等于汇点的最迟发生时间减去从该事件的顶点到汇点的最长路径长度

深度优先遍历和广度优先遍历区别，实现上的区别

       1） 二叉树的深度优先遍历的非递归的通用做法是采用栈，广度优先遍历的非递归的通用做法是采用队列。

       2） 深度优先遍历：对每一个可能的分支路径深入到不能再深入为止，而且每个结点只能访问一次。要特别注意的是，二叉树的深度优先遍历比较特殊，可以细分为先序遍历、中序遍历、后序遍历。具体说明如下：

• 先序遍历：对任一子树，先访问根，然后遍历其左子树，最后遍历其右子树。
• 中序遍历：对任一子树，先遍历其左子树，然后访问根，最后遍历其右子树。
• 后序遍历：对任一子树，先遍历其左子树，然后遍历其右子树，最后访问根。

        广度优先遍历：又叫层次遍历，从上往下对每一层依次访问，在每一层中，从左往右（也可以从右往左）访问结点，访问完一层就进入下一层，直到没有结点可以访问为止。　　　

     3）深度优先搜素算法：不全部保留结点，占用空间少；有回溯操作(即有入栈、出栈操作)，运行速度慢。

          广度优先搜索算法：保留全部结点，占用空间大； 无回溯操作(即无入栈、出栈操作)，运行速度快。

          通常 深度优先搜索法不全部保留结点，扩展完的结点从数据库中弹出删去，这样，一般在数据库中存储的结点数就是深度值，因此它占用空间较少。

所以，当搜索树的结点较多，用其它方法易产生内存溢出时，深度优先搜索不失为一种有效的求解方法。 　

          广度优先搜索算法，一般需存储产生的所有结点，占用的存储空间要比深度优先搜索大得多，因此，程序设计中，必须考虑溢出和节省内存空间的问题。

但广度优先搜索法一般无回溯操作，即入栈和出栈的操作，所以运行速度比深度优先搜索要快些

main函数返回值

• Linux终端里用 echo $?，Windows下，
• cmd中是ECHO %ERROR LEVEL%。
• 如果是IDE，像CodeBlock，下面直接有提示返回值。

测试main函数返回值的意义

　main函数如果返回0，则代表程序正常退出。通常，返回非零代表程序异常退出。

64位系统时int、Long是怎么存储的？

整数据是以补码形式存放的，字符型数据是以ASCⅡ码形式存放的。
长整型long和int型数据在内存中的存储形式是用补码存放的
一般32位系统下，long和int一样，都占四个字节，如，-1就是32个1存储在内存中的。
在64位系统下，int为了bai与之前的兼容，仍占4字节32位，而long被扩展到了8字节64位。
补码的设计使得二进制减法可以转化成加法，这样CPU只需要设计加法器就行了，不用再专门设计减法器了。
结构简化也有利于CPU运行速率的提高。