本文总结一下C++面试时常遇到的问题。C++面试中，主要涉及的考点有：

• 关键字极其用法，常考的关键字有const, sizeof, typedef, inline, static, extern, new, delete等等
• 语法问题
• 类型转换
• 指针以及指针和引用的区别
• 面向对象的相关问题，如虚函数机制等
• 泛型编程的相关问题，如模板和函数的区别等
  
  内存管理，如字节对齐（内存对齐）、动态内存管理、内存泄漏等
  
  编译和链接
  
  实现函数和类

零、序章

0.1 C++与C的对比

1. C++有三种编程方式：过程性，面向对象，泛型编程。
2. C++函数符号由 函数名+参数类型 组成，C只有函数名。所以，C没有函数重载的概念。
3. C++ 在 C的基础上增加了封装、继承、多态的概念
4. C++增加了泛型编程
5. C++增加了异常处理，C没有异常处理
6. C++增加了bool型
7. C++允许无名的函数形参（如果这个形参没有被用到的话）
8. C允许main函数调用自己
9. C++支持默认参数，C不支持
10. C语言中，局部变量必须在函数开头定义，不允许类似for(int a = 0; ;;)这种定义方法。
11. C++增加了引用
12. C允许变长数组，C++不允许
13. C中函数原型可选，C++中在调用之前必须声明函数原型
14. C++增加了STL标准模板库来支持数据结构和算法

一、重要的关键字极其用法

1.1 const

主要用法

C++ 的const关键字的作用有很多，几乎无处不在，面试中往往会问“说一说const有哪些用法”。下面是一些常见的const用法的总结：

除此以外，const的用法还有：

const引用可以引用右值，如const int& a = 1;

注：

• const 成员方法本质上是使得this指针是指向const对象的指针，所以在const方法内，
  
  const 成员函数可以被非const和const对象调用，而const对象只能调用const 成员函数。
• 原因得从C++底层找，C++方法调用时，会传一个隐形的this参数(本质上是对象的地址，形参名为this)进去，所有成员方法的第一个参数是this隐形指针。
• const成员函数的this指针是指向const对象的const指针，当非const对象调用const方法时，实参this指针的类型是非const对象的const指针，赋给const对象的const指针没有问题；但是如果const对象调用非const方法，此时实参this指针是指向const对象的const指针，无法赋给非const对象的const指针，所以无法调用。
• 注意this实参是放在ecx寄存器中，而不是压入栈中，这是this的特殊之处。
• 在类的非成员函数中如果要用到类的成员变量，就可以通过访问ecx寄存器来得到指向对象的this指针，然后再通过this指针加上成员变量的偏移量来找到相应的成员变量。http://blog.csdn.net/starlee/article/details/2062586/
• const 指针、指向const的指针和指向const的const指针，涉及到const的特性“const左效、最左右效”
  
  const 全局变量有内部链接性，即不同的文件可以定义不同的同名const全局变量，使用extern定义可以消除内部链接性，称为类似全局变量，如extern const int a = 10.另一个文件使用extern const int a; 来引用。而且编译器会在编译时，将const变量替换为它的值，类似define那样。

const 常量和define 的区别

1. const常量有数据类型，而宏定义没有数据类型。编译器可以对前者进行类型安全检查，而对后者只进行字符替换，没有类型安全检查，并且在字符替换中可能会产生意想不到的错误（边际效应）。
2. 有些集成化的调试工具可以对const常量进行调试，但是不能对宏定义进行调试。
3. 在C++程序中只使用const常量而不使用宏常量，即const常量完全取代宏常量。
4. 内存空间的分配上。define进行宏定义的时候，不会分配内存空间，编译时会在main函数里进行替换，只是单纯的替换，不会进行任何检查,比如类型，语句结构等，即宏定义常量只是纯粹的置放关系，如#define null 0；编译器在遇到null时总是用0代替null它没有数据类型.而const定义的常量具有数据类型，定义数据类型的常量便于编译器进行数据检查，使程序可能出现错误进行排查,所以const与define之间的区别在于const定义常量排除了程序之间的不安全性.
5. const常量存在于程序的数据段，#define常量存在于程序的代码段
   
   const常量存在“常量折叠”，在编译器进行语法分析的时候，将常量表达式计算求值，并用求得的值来替换表达式，放入常量表，可以算作一种编译优化。因为编译器在优化的过程中，会把碰见的const全部以内容替换掉，类似宏。

1.2 sizeof

1. sizeof关键字不会计算表达式的值，而只会根据类型推断大小。
2. sizeof() 的括号可以省略, 如 sizeof a ;
3. 类A的大小是 所有非静态成员变量大小之和+虚函数指针大小

1.3 static

static的用法有：

（1）声明静态全局变量，如static int a; 静态全局变量的特点：

该变量在全局数据区分配内存; 未经初始化的静态全局变量会被程序自动初始化为0（自动变量的值是随机的，除非它被显式初始化）； 

静态全局变量在声明它的整个文件都是可见的，而在文件之外是不可见的； 　

（2）声明静态局部变量，即在函数内部声明的，静态局部变量的特点：

该变量在全局数据区分配内存； 

静态局部变量在程序执行到该对象的声明处时被首次初始化，即以后的函数调用不再进行初始化； 

静态局部变量一般在声明处初始化，如果没有显式初始化，会被程序自动初始化为0； 

它始终驻留在全局数据区，直到程序运行结束。但其作用域为局部作用域，当定义它的函数或语句块结束时，其作用域随之结束；

（3）声明静态函数，限定函数的局部访问性，仅在文件内部可见

（4）类的静态数据成员，与全局变量相比，静态数据成员的好处有:

静态数据成员没有进入程序的全局名字空间，因此不存在与程序中其它全局名字冲突的可能性； 

可以实现信息隐藏。静态数据成员可以是private成员，而全局变量不能；

（5）类的静态方法

1.4 typedef

typedef 用来定义新的类型，类似的还有#define 和 using (C++11) （应该尽可能用using ,比如 using AAA = int64_t; ）

与宏定义的对比

• define 在预处理阶段进行简单替换，不做类型检查;

• typedef在编译阶段处理，在作用域内给类型一个别名。
• typedef 是一个语句，结尾有分号；#define是一个宏指令，结尾没有分号
  
  typedef int* pInt; 和 #define pInt int* 不等价，前者定义 pInt a, b;会定义两个指针，后者是一个指针，一个int。
• 不能声明为inline的函数
• 包含了递归、循环等结构的函数一般不会被内联。
• 虚拟函数一般不会内联，但是如果编译器能在编译时确定具体的调用函数，那么仍然会就地展开该函数。
• 如果通过函数指针调用内联函数，那么该函数将不会内联而是通过call进行调用。
• 构造和析构函数一般会生成大量代码，因此一般也不适合内联。
• 如果内联函数调用了其他函数也不会被内联。
  
  1.5 inline
  
  inline用来向编译器请求声明为内联函数，编译器有权拒绝。
  
  与宏函数的对比
  
  内联函数在运行时可调试，而宏定义不可以;
  
  编译器会对内联函数的参数类型做安全检查或自动类型转换（同普通函数），而宏定义则不会；
  
  内联函数可以访问类的成员变量，宏定义则不能；
  
  在类中声明同时定义的成员函数，自动转化为内联函数
  
  宏只是预定义的函数，在编译阶段不进行类型安全性检查，在编译的时候将对应函数用宏命令替换。对程序性能无影响

1.6 static const \ const \ static

1. static const 
   
   static const 数据成员可以在类内初始化 也可以在类外，不能在构造函数中初始化，也不能在构造函数的初始化列表中初始化
2. static
   
   static数据成员只能在类外，即类的实现文件中初始化，也不能在构造函数中初始化，不能在构造函数的初始化列表中初始化；
3. const
   
   const数据成员只能在构造函数的初始化列表中初始化；

1.7 explicit

explicit禁止了隐式转换类型，用来修饰构造函数。原则上应该在所有的构造函数前加explicit关键字，当你有心利用隐式转换的时候再去解除explicit，这样可以大大减少错误的发生。

如果一个构造函数 Foo(int) ;则下面的语句是合法的:

Foo f; 

f = 12; // 发生了隐式转换，先调用Foo(int)用12构建了一个临时对象，然后调用赋值运算符复制到 f 中

如果给构造函数加了explicit,即 explicit Foo(int)；就只能进行显示转换，无法进行隐式转换了：

f = 12; // 非法，隐式转换

f = Foo(12); // 合法，显示转换

f = （Foo）12;//合法，显示转换，C风格

1.8 extern

• extern可以置于变量或者函数前，以标示变量或者函数的定义在别的文件中，提示编译器遇到此变量和函数时在其他模块中寻找其定义。此外extern也可用来进行链接指定。

二、语法问题

2.1 a++ 与 ++a的区别

• a++ 返回加之前的值，++a返回加之后的a变量
• a++返回的是一个临时变量，是右值，无法赋值；++a返回的是变量a，是左值

2.2 switch语句

• switch语句的表达式必须是整型int , char, short等。

2.3 函数调用过程

http://www.cnblogs.com/biyeymyhjob/archive/2012/07/20/2601204.html

https://zhuanlan.zhihu.com/p/25816426

• 执行到函数调用指令时：
  
  +++++++++ 入栈 ++++++++++++
  
  将实参从右向左压入栈
  
  压入返回地址
  
  压入主调函数的基地址
  
  跳到被调用函数的地址，执行函数代码，局部变量按声明顺序依次压入栈
  
  将返回值放入寄存器eax(累加器)中
  
  +++++++++ 出栈 ++++++++++++
  
  局部变量全部出栈
  
  返回地址出栈，找到原执行地址
  
  形参出栈
  
  赋值操作将寄存器中的返回值赋给左值（如果有的话）

2.4 左值与右值

• 判断左值和右值的标准是是否可以取地址。右值和左值不同，有可能存在于寄存器中，无法取地址，无法被赋值，临时变量就是右值，存放在寄存器中，被赋给左值后被释放。

2.5 C语言标识符

• 关键字、预定义标识符、用户标识符(不能以数字开头)
  
  a123 // 合法
  
  _a // 合法
  
  _0 // 合法
  
  0asdasd// 非法

2.6 全局变量的优缺点

优点：

（1）可以减少变量的个数

（2）减少由于实际参数和形式参数的数据传递带来的时间消耗。

缺点：

（1）全局变量保存在静态存贮区，程序开始运行时为其分配内存，程序结束释放该内存。与局部变量的动态分配、动态释放相比，生存期比较长，因此过多的全局变量会占用较多的内存单元。

（2）全局变量破坏了函数的封装性能。前面的章节曾经讲过，函数象一个黑匣子，一般是通过函数参数和返回值进行输入输出，函数内部实现相对独立。但函数中 如果使用了全局变量，那么函数体内的语句就可以绕过函数参数和返回值进行存取，这种情况破坏了函数的独立性，使函数对全局变量产生依赖。同时，也降低了该 函数的可移植性。

（3）全局变量使函数的代码可读性降低。由于多个函数都可能使用全局变量，函数执行时全局变量的值可能随时发生变化，对于程序的查错和调试都非常不利。

2.7 复合类型有哪些？

6个

class, struct, union, enum, 数组，指针

2.8 运算符优先级和结合性？

结合性有两种，一种是自左至右，另一种是自右至左，大部分运算符的结合性是自左至右，只有单目运算符、三目运算符的赋值运算符的结合性自右至左。

优先级有15种。记忆方法如下：

记住一个最高的：构造类型的元素或成员以及小括号。

记住一个最低的：逗号运算符。

剩余的是一、二、三、赋值。

意思是单目、双目、三目和赋值运算符。

在诸多运算符中，又分为：

算术、关系、逻辑。

两种位操作运算符中，移位运算符在算术运算符后边，逻辑位运算符在逻辑运算符的前面。再细分如下：

算术运算符分 *，/，%高于+，-。

关系运算符中，〉，〉=，<，<=高于，！=。

逻辑运算符中，除了逻辑求反（！）是单目外，逻辑与（&&）高于逻辑或（||）。

逻辑位运算符中，除了逻辑按位求反（~）外，按位与（&)高于按位半加（^)，高于按位或（|）。

这样就将15种优先级都记住了，再将记忆方法总结如下：

去掉一个最高的，去掉一个最低的，剩下的是一、二、三、赋值。双目运算符中，顺序为

算术、移位、关系(>,<,)、逻辑位和逻辑（&& ||）。

2.9 using 声明和using 编译指令的区别？哪个更好？

using声明是指类似using std::vector;这种的，using编译指令是指using namespace std;这种的。区别：

（1）using声明使特定的标示符可用，using编译指令使整个名称空间可用。

（2）假设名称空间和声明区域定义了相同的名称。如果试图使用using声明将名称空间的名称导入该声明区域，则这两个名称会发生冲突，从而出错。如果使用using编译指令将该名称空间的名称导入该声明区域，则局部版本将隐藏名称空间版本。

（3）一般来说，使用using声明比使用using编译指令更安全，这是由于它只导入指定的名称。如果该名称与局部名称发生冲突，编译器将付出指示。using编译指令导入所有名称，包括可能并不需要的名称。如果与局部名称发生冲突，则局部名称将覆盖名称空间版本，而编译器并不会发出警告。

2.10 for循环的效率问题

http://blog.sina.com.cn/s/blog_549941cb01013qgx.html

1. 最长循环放到内部可以提高I cache的效率,降低因为循环跳转造成cache的miss以及流水线flush造成的延时
2. 多次相同循环后也能提高跳转预测的成功率，提高流水线效率
3. 编译器会自动展开循环提高效率, 这个不一定是必然有效的
   
   但不是绝对正确的，比如:

1 int x[1000][100];

2 for(i=0;i<1000;i++)

3 for(j=0;j<100;j++)

4 {

5 //access x[i][j]

6 }

7

8 int x[1000][100];

9 for(j=0;j<100;j++)

10 for(i=0;i=1000;i++)

11 {

12 //access x[i][j]

13 }

14

这时候第一个的效率就比第二个的高，原因嘛和硬件也有一些关系，CPU对于内存的访问都是通过数据缓存(cache)来进行的。

三、类型转换

3.1 四种类型强制转换

dynamic_cast：该转换符用于将一个指向派生类的基类指针或引用转换为派生类的指针或引用。

const_cast：最常用的用途就是删除const属性。

static_cast：static_cast本质上是传统c语言强制转换的替代品，比C类型转换更严格, 该操作符用于非多态类型的转换，任何标准转换都可以使用他，即static_cast可以把int转换为double，但不能把两个不相关的类对象进行转换，比如类A不能转换为一个不相关的类B类型。static_cast在类对象和基础类型转换中，会调用类的构造函数，和类型转换运算符比如operator int()，来进行显示转换。

reinterpret_cast：该操作符用于将一种类型转换为另一种不同的类型，比如可以把一个整型转换为一个指针，或把一个指针转换为一个整型，因此使用该操作符的危险性较高，一般不应使用该操作符。

四、指针

4.1 指针与引用的区别

1. 指针是一个变量，引用只是别名
2. 指针需要解引用才能访问对象，引用不需要
3. 引用在定义时必须初始化，且以后不可转移引用的对象，指针可以
   
   引用没有const，即int& const a ;没有；而指针有const指针，即int* const ptr;
4. 引用不可以为空；而指针可以
5. 指针变量需要分配栈空间；而引用不需要，仅仅是个别名
6. sizeof(引用)得到对应对象的大小；sizeof(指针)得到指针大小
7. 指针加法和引用加法不一样
8. 引用不需要释放内存空间，在编译时就会优化掉

4.2 指针与数组名的区别

1. 数组名不是指针，对数组名取地址，得到整个数组的地址
2. 数组名 + 1会跳过整个数组的大小，指针+1只会跳过一个元素的大小
3. 数组名作为函数参数传递时，退化为指针
4. sizeof(数组名)返回整个数组的大小，sizeof(指针)返回指针大小
5. 数组名无法修改值，是常量
6. int (*p)[] = &arr; 才是正确的数组指针写法

4.3 野指针、空指针的概念

1. 野指针是指指向无效内存的指针，不能对野指针取内容，delete
2. 空指针是指置为0\NULL\nullptr的指针，可以对空指针delete多次
   
   五、面向对象

5.1 面向对象的三大特性

三大特性：封装,继承,多态

1. 封装：封装是实现面向对象程序设计的第一步，封装就是将数据或函数等集合在一个个的单元中（我们称之为类）。封装的意义在于保护或者防止代码（数据）被我们无意中破坏。
2. 继承：继承主要实现重用代码，节省开发时间。子类可以继承父类的一些东西。
3. 多态：同一操作作用于不同的对象，可以有不同的解释，产生不同的执行结果。分为编译时多态和运行时多态。

转自：

https://blog.csdn.net/csdn_chai/article/details/78041050