C和C++的区别？

1. C是面向过程的语言，C++是面向对象的语言
2. C++中new和delete是对内存分配的运算符，取代了C中的malloc和free
3. C++中有引用的概念，C中没有
4. C++引入了类的概念，C中没有
5. C++有函数重载，C中不能
6. C变量只能在函数的开头处声明和定义，而C++随时定义随时使用

C++和Java之间的区别？

1. Java的应用在高层，C++在中间件和底层
2. Java语言简洁；取消了指针带来更高的代码质量；完全面向对象，独特的运行机制是其具有天然的可移植性。
3. Java在web应用上具有C++无可比拟的优势
4. 垃圾回收机制的区别。C++ 用析构函数回收垃圾,Java自动回收,写C和C++程序时一定要注意内存的申请和释放。
5. Java用接口(Interface)技术取代C++程序中的多继承性

1. 面向对象是一种基于对象的、基于类的的软件开发思想。面向对象具有继承、封装、多态的特性。
2. 面向过程：

指针和引用的区别

1. 指针保存的是指向对象的地址，引用相当于变量的别名
2. 引用在定义的时候必须初始化，指针没有这个要求
3. 指针可以改变地址，引用必须从一而终
4. 不存在空应引用，但是存在空指针NULL，相对而言引用更加安全
5. 引用的创建不会调用类的拷贝构造函数

c/c++中的内存分区

1. 栈区：由编译器自动分配和释放，用来存放函数的参数、局部变量。存放在栈中的数据只在当前函数以及下一层函数中有效，函数一旦结束，这些数据就被释放了；
2. 堆区：有程序员手动分配和释放，如果程序员没有释放则在整个程序结束的时候用OS释放，忘记释放的话就会出现内存泄漏的问题；
3. 全局（静态）区：用来存储全局变量和静态变量，程序结束后由OS负责释放；
4. 常量区：存放字面量，不允许修改，如“hello world”，2 ， ‘c’，程序结束的时候由OS负责释放；
5. 代码区：存放代码（如函数），不允许修改，但可以执行；

c/c++中的内存分配

1. 在静态存储区分配：内存在程序编译的时候就已经分配好了，这块内存在程序运行的整个期间都存在。例如：全局变量、static变量；
2. 在栈上分配：函数内申请的局部变量，在函数执行结束后就会被释放掉，效率高，但是栈的内存容量有限；
3. 从堆上分配：也称之为动态内存分配，程序在运行期间使用malloc和new申请任意的多少空间，程序员自己负责在何时使用free或delete释放掉申请的那块内存。这部分内存的生命周期是人为决定的，使用上非常灵活，但是有人为介入，所以忘记释放掉这块内存的时候就会出现内存泄露的问题，并且频繁的分配和释放不同大小的堆内存会产生内存碎片的问题；

new/delete与malloc/free的区别

1. new是运算符，malloc是C语言库函数
2. new可以重载，malloc不能重载
3. new的变量是数据类型，malloc的是字节大小
4. new可以调用构造函数，delete可以调用析构函数，malloc/free不能
5. new返回的是指定对象的指针，而malloc返回的是void*，因此malloc的返回值一般都需要进行类型转化
6. malloc分配的内存不够的时候可以使用realloc扩容，new没有这样的操作
7. new内存分配失败抛出bad_malloc，malloc内存分配失败返回NULL值
8. 申请内存的位置不同；new操作符是从自由存储区上为对象动态分配内存空间的，而malloc函数则是从堆上分配内存空间的；（自由存储区是c++基于new操作符的一个抽象概念，凡是通过new操作符进行内存申请的，该内存就被称之为自由存储区。该存储区的位置是由new在哪里为对象分配内存决定的，既可以是堆，也可以是静态存储区）

volatile关键字

1. C/C++ 中的 volatile 关键字和 const 对应，用来修饰变量，通常用于建立语言级别的 memory barrier（内存屏障）。

2.   volatile 关键字是一种类型修饰符，用它声明的类型变量表示可以被某些编译器未知的因素更改，比如：操作系统、硬件或者其它线程等。遇到这个关键字声明的变量，编译器对访问该变量的代码就不再进行优化，从而可以提供对特殊地址的稳定访问。声明时语法：int volatile vInt; 当要求使用 volatile 声明的变量的值的时候，系统总是重新从它所在的内存读取数据，即使它前面的指令刚刚从该处读取过数据，而且读取的数据立刻被保存，这样可以防止出现由于编译器优化读取和存储，可能暂时使用寄存器中的值，如果这个变量由别的程序更新的话，将出现变量不一致的情况。
   
3. 访问寄存器要比访问内存要块，因此CPU会优先访问该数据在寄存器中的存储结果，但是内存中的数据可能已经发生了改变，而寄存器中还保留着原来的结果。为了避免这种情况的发生将该变量声明为volatile，告诉CPU每次都从内存去读取数据。
4. 一个参数可以即是const又是volatile的吗？可以，一个例子是只读状态寄存器，是volatile是因为要告诉编译器它可能被其他程序改变，而是const告诉在程序里面不应该试图去修改它，但是它是可以被程序外的东西修改。
5. 举例说明：在DSP开发（数字信号处理开发）中，经常要等待某个时间的触发，所以经常会写出这样的程序：

short flag;

void test()
{
    do1();
    while(flag == 0);
    do2();
}
//这段程序等待内存变量flag的值变为非0之后再运行do2（），变量flag的值由别的程序更改，
//这个程序可能是某个硬件中断服务程序。例如：如果某个按钮按下的话，就会对DSP产生中断，
//在按键中断程序中修改flag为1，这样上面的程序就能够得以继续运行。但是，
//编译器并不知道flag的值会被别的程序修改，因此在它进行优化的时候，可能会把flag的值先
//读入某个寄存器，然后等待那个寄存器变为1。如果不幸进行了这样的优化，
//那么while循环就变成了死循环，因为寄存器的内容不可能被中断服务程序修改。
//为了让程序每次都读取真正flag变量的值，就需要定义为如下形式：
volatile short flag;

        需要注意的是，没有volatile也可能能正常运行，但是可能修改了编译器的优化级别之后就又不能正常运行了。因此经常会出现debug版本正常，但是release版本却不能正常的问题。所以为了安全起见，只要是等待别的程序修改某个变量的话，就加上volatile关键字。volatile的本意是“易变的”,由于访问寄存器的速度要快过RAM，所以编译器一般都会作减少存取外部RAM的优化,所以为了不让编译器进行这种优化，就需要加volatile。

static关键字的作用

1. 修饰全局变量
2. 修饰局部变量
3. 修饰全局函数 --- 限制它的作用域只能在本文件之内。可以和其他文件的函数重名
4. 修饰局部函数
5. 修饰类的成员变量、成员函数

静态全局变量、全局变量、静态局部变量、局部变量的区别

1. 静态全局变量和全局变量都属于全局区（静态区），区别在于静态全局变量只作用于本文件中，而全局变量可以被其他文件调用；
2. 静态局部变量和局部变量的区别：静态局部变量属于全局区，而函数内部的局部变量属于栈区；静态局部变量在函数执行结束后，不会被销毁，且不能被其他函数调用，会在整个程序结束后被OS回收。而局部变量在函数调用结束后就会被销毁；静态局部变量子啊编译期间只会赋值一次，以后每次函数被调用的时候，都不会再进行赋值操作了。而局部变量，函数调用一次，就赋值一次；静态局部变量如果在定义的时候没有赋初值，就会默认为0，局部变量则为一个随机值。
3. 一个参数可以即是const又是volatile的吗？可以，一个例子是只读状态寄存器，是volatile是因为它可能被意想不到的被改变，是const告诉程序不应该试图去修改他

extern关键字作用

声明一个外部变量。

const关键字的作用

1. const修饰全局变量
2. const修饰局部变量
3. const *常量指针，内容不可以改
4.  * const 指针常量 ，地址不可以改
5. *const* 指向常量的指针常量，内容地址都不可以改
6. const修饰引用做形参
7. const修饰成员变量，必须在构造函数列表中初始化
8. const修饰成员函数，不能和static关键字同时使用，因为static关键字修饰静态成员函数，静态成员函数中不包含this指针，即不能被实例化，而const修饰的实际是成员函数的this指针。const成员函数只能调用const成员函数，const类对象只能调用const成员函数
9. const修饰类对象：对象的任何成员都不可以被修改，只能调用const成员函数
10. 构造函数和静态成员函数不可以声明为const函数

define/const/inline的区别

本质：define只是字符串替换，const参与编译运行，具体的：

1. define不会做类型检查，const拥有类型，会执行相应的类型检查
2. define仅仅是宏替换，不占用内存，而const会占用内存
3. const内存效率更高，编译器通常将const变量保存在符号表中，而不会分配存储空间，这使得它成为一个编译期间的常量，没有存储和读取的操作

#include <iostream>
using namespace std;

int main ()
{
    cout << "Value of __LINE__ : " << __LINE__ << endl;
    cout << "Value of __FILE__ : " << __FILE__ << endl;
    cout << "Value of __DATE__ : " << __DATE__ << endl;
    cout << "Value of __TIME__ : " << __TIME__ << endl;

    return 0;
}

Value of __LINE__ : 6
Value of __FILE__ : test.cpp
Value of __DATE__ : Feb 28 2011
Value of __TIME__ : 18:52:48

c语言的预处理理论

    1.从源码到可执行文件的过程：

    2.预处理的意义

#if...#endif条件编译预处理命令

#define            定义一个预处理宏
#undef            取消宏的定义

#if                   编译预处理中的条件命令，相当于C语法中的if语句
#ifdef              判断某个宏是否被定义，若已定义，执行随后的语句
#ifndef            与#ifdef相反，判断某个宏是否未被定义
#elif                若#if, #ifdef, #ifndef或前面的#elif条件不满足，则执行#elif之后的语句，相当于C语法中的else-if
#else              与#if, #ifdef, #ifndef对应, 若这些条件不满足，则执行#else之后的语句，相当于C语法中的else
#endif             #if, #ifdef, #ifndef这些条件命令的结束标志.
defined         　与#if, #elif配合使用，判断某个宏是否被定义

#ifdef  标示符
      程序段1
     #else
         程序段2
     #endif   

#if 表达式
      程序段1
    #else
         程序段2
    #endif

    3.应用举例

#ifndef ABCD_H
#define ABCD_H
 
// ... some declaration codes
 
#endif // #ifndef ABCD_H

 #ifdef _DEBUG
 
 // ... do some operations
 
 #endif
  
 #ifdef _WIN32
  
 // ... use  Win32 API
 
 #endif

#if defined(VAX) && defined(UNIX) && !defined(DEBUG) 

#ifdef ABC
// ... codes while definded ABC
#elif (CODE_VERSION > 2)
// ... codes while CODE_VERSION > 2
#else
// ... remained cases
#endif // #ifdef ABC 

#if 常量表达式1
// ... some codes
#elif 常量表达式2
// ... other codes
#elif 常量表达式3
// ...
...
#else
// ... statement
#endif

#if MACRO_NON_DEFINED // 等价于

#if 0

#include <stdio.h> #include "b.h"

#include "a.h"

#include "a.h" #include "b.h"  int main()
{  printf("Hello!");
    return 0；
}

#ifndef _A_H #define _A_H #include "a.h" #endif

#ifndef <标识>
#define <标识>

......
......

#endif

#ifndef _STDIO_H_
#define _STDIO_H_

......

#endif

在程序首部定义#ifdef HNLD：

#ifdef HNLD

include"n166_hn.c"

#endif

#ifdef DEBUG

printf(" Now is in hunan !");

#endif

#ifndef TEST

i=dial();

//程序调试运行时绕过此语句

#else

i=0;

#endif

#ifndef AAA
#define AAA
...
int i;
...
#endif

<x.h>
#ifndef __X_H__
#define __X_H__
extern int i;
#endif //__X_H__
<x.c>
int i;

    1.定义

    2.注意事项：

#define MAX(x, y)  ({\
int _x = x;\
int _y = y;\
_x > _y ? _x : _y;\
})

//适用各种类型的，类型函数模板
#define MAX(x, y)  ({\
typeof(x) _x = x;\
typeof(y) _y = y;\
_x > _y ? _x : _y;\
})

//x，y类型不同的时候提示不能进行比较
#define MAX(x, y)  ({\
typeof(x) _x = x;\
typeof(y) _y = y;\
_x > _y ? _x : _y;\
})

#include <stdio.h>

#define M   10
#define N   M
#define X(a,b)  ((a)*(b))
#define Max(a,b)    (((a)>(b)) ? (a) : (b))
//#define year    (365*24*60*60)UL   //在Linux中GCC测试出错
#define year    (365UL *24*60*60)     //在Linux中GCC测试正确

 int main(void)
{
    int i = N;
    int k, x, y, m, n;
    printf("%d\n",i);       //输出：10

    k = X(3+i, i - 8);      //解析为：k = ((3+i)*(i - 8));
    printf("k = %d\n",k);   //输出：26
    m =  Max(3,5);          //解析为：m = (((3)>(5)) ? (3) : (5));
    printf("Max is %d\n",m);//输出：5
    n = year;               //解析为：n = (365UL*24*60*60);
    printf("%d\n", n);      //输出：31536000

    return 0 ;
}

    3.带参宏和带参函数的区别（宏定义的缺陷）

C++构造函数能抛异常吗？析构呢？

• 构造函数和析构函数中的异常

  1、构造函数可以抛出异常。

  2、c++标准指明析构函数不能、也不应该抛出异常。

  more effective c++关于第2点提出两点理由：

  1）如果析构函数抛出异常，则异常点之后的程序不会执行，如果析构函数在异常点之后执行了某些必要的动作比如释放某些资源，则这些动作不会执行，会造成诸如资源泄漏的问题。

  2）通常异常发生时，c++的机制会调用已经构造对象的析构函数来释放资源，此时若析构函数本身也抛出异常，则前一个异常尚未处理，又有新的异常，会造成程序崩溃的问题。

  解决办法：

  1）永远不要在析构函数抛出异常。

  2）通常第一点有时候不能保证。可以采取如下的方法

  ~ClassName()
  {
    try{
        do_something();
    }
    catch( ){  // 这里可以什么都不做，只是保证catch块的程序抛出的异常不会被扔出析构函数之外。
     }
  }

  
  

1. 虚函数的执行依赖于虚函数表（对象内存的首地址存放的是虚函数列表的首地址）。而虚函数表需要在构造函数中进行初始化工作，即初始化vptr，让他指向正确的虚函数表。而在构造对象期间，虚函数表还没有被初始化，将无法进行。
2. 在类的继承中，如果有基类指针指向派生类，那么用基类指针delete时，如果不定义成虚函数，派生类中派生的那部分无法析构。通常应该为基类提供一个虚析构函数，这样派生类对象在释放度的时候，会先调用派生类析构，再调用基类析构，避免出现内存泄露的问题。
3. 构造函数不要调用虚函数。在基类构造的时候，虚函数是非虚，不会走到派生类中，既是采用的静态绑定。显然的是：当我们构造一个子类的对象时，先调用基类的构造函数，构造子类中基类部分，子类还没有构造，还没有初始化，如果在基类的构造中调用虚函数，如果可以的话就是调用一个还没有被初始化的对象，那是很危险的，所以C++中是不可以在构造父类对象部分的时候调用子类的虚函数实现。但是不是说你不可以那么写程序，你这么写，编译器也不会报错。只是你如果这么写的话编译器不会给你调用子类的实现，而是还是调用基类的实现。

有哪些内存泄漏？如何判断内存泄漏？如何定位内存泄漏？野指针问题？

==内存泄漏类型：==

1. 堆内存泄漏 （Heap leak）。堆内存指的是程序运行中根据需要分配通过malloc,realloc new等从堆中分配的一块内存，再是完成后必须通过调用对应的 free或者delete 删掉。如果程序的设计的错误导致这部分内存没有被释放，那么此后这块内存将不会被使用，就会产生Heap Leak.
2. 系统资源泄露（Resource Leak）.主要指程序使用系统分配的资源比如 Bitmap,handle ,SOCKET等没有使用相应的函数释放掉，导致系统资源的浪费，严重可导致系统效能降低，系统运行不稳定。

==检测内存泄漏：==

1. 在windows平台下通过CRT中的库函数进行检测；
2. 在可能泄漏的调用前后生成块的快照，比较前后的状态，定位泄漏的位置
3. Linux下通过工具valgrind检测

==野指针：指向被释放的或者访问受限的内存的指针==

1. 指针变量没有被初始化（如果值不定，可以初始化为NULL）；
2. 指针被free或delete以后，没有置为NULL，free和delete只是把指针指向的内存给释放掉了，并没有把指针本身释放掉，此时的指针直系那个的是“垃圾”内存，应该将释放后的指针置为NULL
3. 指针操作超越了变量的作用范围，比如返回指向栈内存的指针就是野指针；

foo = new int[5];//如果分配失败的话，就会抛出异常

int * foo = new (nothrow)int [5];
if(foo == nullptr)
{
    dosomething();
}

int main()
{
    auto a = make_shared<string>("hello world");
}
//我们定义了一个变量a，它的初始值是一个make_share类型。这样我们就新建了一个指向string
//智能指针shared_ptr；相比于之前的c++标准，这样会更加简便，利于我们快速完成程序设计；

int main()
{
    const int b = 10;
    int c = 20;
    decltype(b) x = 0;
    decltype(c) y = 1;
    cout << x << " " << y << endl;
}
//定义一个常量b，设定其初始值为10，又定义了一个初值为20的变量c，然后通过decltype关键字定义
//了两个变量x、y。让编译器通过推断括号里的表达式来判断x，y的类型。

int main()
{
    int *p = nullptr;
    int *q = new int(10);
    p = q;
    delete q;
}

int main()
{
    constexpr const int val = 100;
    constexpr int val2 = val + 1;
}
//我们定义了一个常量val为100，并用其来初始化另外一个常量val2

int main()
{
    std::vector<int> arr(5 , 100);
    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;
}

int main()
{
   int a = 0;
   auto f = [=]{return a;}
   a += 1;
   cout << f() << endl;//输出0
   int b = 0;
   auto f1 = [&a]{return a;}
   b += 1;
   cout << f1() << endl;//输出1
    
}
//[capture list] (parameter list) ->return type{function body}
//capture list捕获列表，也就是lambda所在函数中的局部变量的列表，如果没有，可为空；
//   用来控制lambda表达式所能够访问的外部变量，以及如何去访问这些变量；
//   (1)[]不捕获任何变量
//   (2)[&]捕获外部作用域中所有变量，并作为函数引用在函数体中使用（即按引用捕获）
//   (3)[=]捕获外部作用域中所有变量，并作为副本在函数体中使用（即按值捕获）
//   (4)[= , &foo]按值捕获外部作用域中所有的变量，并按引用捕获foo变量
//   (5)[bar]按值捕获bar变量，同时不捕获其他变量
//   (6)[this]捕获当前类中的this指针，让lambda表达式拥有和当前类成员函数通样的访问权限
//return type表示该lambda表达式的返回类型；
//parameter list为形参列表
//注意：如果有返回类型，lambda表达式必须使用尾置返回来确定类型。
//lambda表达式必须包括捕获列表和函数体，另外几个可以省略；

#include <initializer_list>
struct A{
    int a;
    float b;
};

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

class Magic{
public:
    Magic(std::initializer_list<int> list){}    
}

int main()
{
    //统一的初始化语法
    A a{1 , 1.1};
    B b{2, 2.2};
    Magic magic = {1,2,3,4,5};
    std::vector<int> vec = {1,2,3,4,5};
}

template class std::vector<bool>;//强行实例化
extern template class std::vector<double>;//不在该编译文件中实例化模板

std::vector<std::vector<int> > vec;
//使用模板类vector定义了一个二维向量容器
std::vector<std::vector<int>> vec;//连续的>>变得合法了，可以顺利通过编译

template <typename T>
using newtype = sunType<int , T , 1>;

//我们可能定义了一个加法函数：
template<typename T, typename U>
auto add(T x, U y) -> decltype(x+y) {
    return x+y
}
//但在使用时发现，要使用 add，就必须每次都指定其模板参数的类型。
//在 C++11 中提供了一种便利，可以指定模板的默认参数：
template<typename T = int, typename U = int>
auto add(T x, U y) -> decltype(x+y) {
    return x+y;
}

class Base{
pubulic:
    int val1;
    int val2;
    Base()
    {
        val1  = 1;
    }
    Base(int value):Base()//委托构造，将val的值赋值为1（不管传的参数value是多少），val2的值赋值为2；
    {
        val2 = 2;
    }
}

struct A
{
  A(int i) {}
  A(double d,int i){}
  A(float f,int i,const char* c){}
  //...等等系列的构造函数版本
}；
struct B:A
{
  B(int i):A(i){}
  B(double d,int i):A(d,i){}
  B(folat f,int i,const char* c):A(f,i,e){}
  //......等等好多个和基类构造函数对应的构造函数
}；

//在c++11中的继承构造： struct A
{
  A(int i) {}
  A(double d,int i){}
  A(float f,int i,const char* c){} //...等等系列的构造函数版本  }； struct B:A
{  using A::A; //关于基类各构造函数的继承一句话搞定 //...... }；

std::array<int, 4> arr= {1,2,3,4};

int len = 4;
std::array<int, len> arr = {1,2,3,4}; // 非法, 数组大小参数必须是常量表达式
//当我们开始用上了 std::array 时，难免会遇到要将其兼容 C 风格的接口，这里有三种做法：
void foo(int *p, int len) {
    return;
}
std::array<int 4> arr = {1,2,3,4};
// C 风格接口传参
// foo(arr, arr.size());           // 非法, 无法隐式转换
foo(&arr[0], arr.size());
foo(arr.data(), arr.size());
// 使用 `std::sort`
std::sort(arr.begin(), arr.end());

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

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

 （4）元祖     

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

        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';
}


//合并两个元组，可以通过 std::tuple_cat 来实现。
auto new_tuple = std::tuple_cat(get_student(1), std::move(t));

    11.正则表达式

        主要就是四个操作：匹配、搜索、替换、切割

        

            (1)匹配

                

         （2）搜索

                

                    

           （4）切割

                    

    12.语言级线程支持  

纯虚函数的作用和实现方式

        

    优点：(1) 不指定一块内存大小的数组的连续存储，即可以像数组一样操作，但可以对此数组进行动态操作。通常体现在push_back() pop_back()

               (2) 随机访问方便，即支持[ ]操作符和vector.at()
               (3) 节省空间。
   缺点： (1) 在内部进行插入删除操作效率低。
               (2) 只能在vector的最后进行push和pop，不能在vector的头进行push和pop。
               (3) 当动态添加的数据超过vector默认分配的大小时要进行整体的重新分配、拷贝与释放 

      （3）list：

                每一个结点都包括一个信息快Info、一个前驱指针Pre、一个后驱指针Post。可以不分配必须的内存大小方便的进行添加和删除操作。使用的是非连续的内存空间进行存储。
   优点： (1) 不使用连续内存完成动态操作。
               (2) 在内部方便的进行插入和删除操作
               (3) 可在两端进行push、pop
   缺点： (1) 不能进行内部的随机访问，即不支持[ ]操作符和vector.at()
               (2) 相对于verctor占用内存多

              list<T>容器是双向链表，因此可以有效的在任何位置添加和删除。列表的缺点是不能随机访问内容，要想访问内容必须在列表的内部从头开始便利内容，或者从尾部开始。

    （4）deque:

        deque：双端队列 double-end queue

   deque是在功能上合并了vector和list。
   优点： (1) 随机访问方便，即支持[ ]操作符和vector.at()
               (2) 在内部方便的进行插入和删除操作
               (3) 可在两端进行push、pop
   缺点： (1) 占用内存多

        deque<T>容器：非常类似vector<T>，且支持相同的操作，但是它还可以在序列开头添加和删除。deque<T>双端队列容器与矢量容器基本类似，具有相同的函数成员，但是有点不同的是它支持从两端插入和删除数据，所以就有了两个函数：push_front和pop_front。并且有两个迭代器变量。

       (5) 使用区别：

         1 如果你需要高效的随即存取，而不在乎插入和删除的效率，使用vector 
         2 如果你需要大量的插入和删除，而不关心随即存取，则应使用list 
         3 如果你需要随即存取，而且关心两端数据的插入和删除，则应使用deque

    4.关联容器：

        Map, Set属于标准关联容器，使用了非常高效的平衡检索二叉树：红黑树，他的插入删除效率比其他序列容器高是因为不需要做内存拷贝和内存移动，而直接替换指向节点的指针即可。Set和Vector的区别在于Set不包含重复的数据。Set和Map的区别在于Set只含有Key，而Map有一个Key和Key所对应的Value两个元素。Map和Hash_Map的区别是Hash_Map使用了Hash算法来加快查找过程，但是需要更多的内存来存放这些Hash桶元素，因此可以算得上是采用空间来换取时间策略。

        

字节对齐的原则

1. 从0位置开始存储；
2. 变量存储的起始位置是该变量大小的整数倍；
3. 结构体总的大小是其最大元素的整数倍，不足的后面要补齐；
4. 结构体中包含结构体，从结构体中最大元素的整数倍开始存；
5. 如果加入pragma pack(n) ，取n和变量自身大小较小的一个。

空结构体的sizeof()返回值

• 答案是1

静态连接与动态链接的区别

1. 静态链接
   所谓静态链接就是在编译链接时直接将需要的执行代码拷贝到调用处，优点就是在程序发布的时候就不需要依赖库，也就是不再需要带着库一块发布，程序可以独立执行，但是体积可能会相对大一些。
2. 动态链接
   所谓动态链接就是在编译的时候不直接拷贝可执行代码，而是通过记录一系列符号和参数，在程序运行或加载时将这些信息传递给操作系统，操作系统负责将需要的动态库加载到内存中，然后程序在运行到指定的代码时，去共享执行内存中已经加载的动态库可执行代码，最终达到运行时连接的目的。优点是多个程序可以共享同一段代码，而不需要在磁盘上存储多个拷贝，缺点是由于是运行时加载，可能会影响程序的前期执行性能。

重写、重载与隐藏的区别

必须在构造函数初始化式里进行初始化的数据成员有哪些

C++四种类型转换

1. const_cast用于将const变量转为非const
2. static_cast用的最多，对于各种隐式转换，非const转const，void*转指针等, static_cast能用于多态想上转化，如果向下转能成功但是不安全，结果未知；
3. dynamic_cast用于动态类型转换。只能用于含有虚函数的类，用于类层次间的向上和向下转化。只能转指针或引用。向下转化时，如果是非法的对于指针返回NULL，对于引用抛异常。要深入了解内部转换的原理。
4. reinterpret_cast几乎什么都可以转，比如将int转指针，可能会出问题，尽量少用；
5. 为什么不使用C的强制转换？C的强制转换表面上看起来功能强大什么都能转，但是转化不够明确，不能进行错误检查，容易出错。

如何让一个类不能实例化？

• 将类定义为抽象基类或者将构造函数声明为private。

如何让main函数之前执行函数？

1. C++中在main函数之前定义一个全局对象，调用构造函数。
2. C语言中使用gcc的attribute关键字，声明constructor和destructor。

C++如何创建一个类，使得他只能在堆或者栈上创建？

1. 只能在堆上生成对象：将析构函数设置为私有。
   原因：C++是静态绑定语言，编译器管理栈上对象的生命周期，编译器在为类对象分配栈空间时，会先检查类的析构函数的访问性。若析构函数不可访问，则不能在栈上创建对象。
2. 只能在栈上生成对象：将new 和 delete 重载为私有。
   原因：在堆上生成对象，使用new关键词操作，其过程分为两阶段：第一阶段，使用new在堆上寻找可用内存，分配给对象；第二阶段，调用构造函数生成对象。将new操作设置为私有，那么第一阶段就无法完成，就不能够再堆上生成对象。