c++三大特性#

封装

最开始接触代码是C语言，那么开始写一些逻辑代码的时候会很麻烦，因为你要在函数中定义变量，然后按顺序写对应的逻辑，接着可以将逻辑封装成函数。当时会感觉很麻烦，因为很散装，知道后面学了struct结构体，把对应逻辑需要的数据可以放到一个结构体里面，这样就会比较好看。接着出现的问题就是数据封装到了一起，但是处理数据对应的逻辑即函数却还是在外面。因此就有了将数据和对应逻辑进行封装的类的出现。

封装就是将抽象得到的数据和行为相结合，形成一个有机的整体，也就是将数据与操作数据的源代码进行有机的结合，形成类，其中数据和函数都是类的成员，目的在于将对象的使用者和设计者分开，可以隐藏实现细节包括包含私有成员，使得代码模块增加安全指数，同时提高软件的可维护性和可修改性。

所以总结来说封装这个特性包含两三特点：

1. 结合性，即是将属性和方法结合
2. 信息隐蔽性，利用接口机制隐蔽内部实现细节，只留下接口给外界调用
3. 实现代码重用

继承

类的派生指的是从已有类产生新类的过程。原有的类成为基类或父类，产生的新类称为派生类或子类，子类继承基类后，可以创建子类对象来调用基类的函数，变量等。

一般来说有如下三种继承方式：

1. 单一继承：继承一个父类，这种继承称为单一继承，这也是我们用的做多的继承方式。
2. 多重继承：一个派生类继承多个基类，类与类之间要用逗号隔开，类名之前要有继承权限，假使两个或两个基类都有某变量或函数，在子类中调用时需要加类名限定符如obj.classA::i = 1；
3. 菱形继承：多重继承掺杂隔代继承1-n-1模式，此时需要用到虚继承，例如 B，C虚拟继承于A，D再多重继承B，C，否则会出错。后面有将具体虚继承怎么做。

此外还有继承权限的问题，如下图：

多态

可以简单概括为“一个接口，多种方法”，即用的是同一个接口，但是效果各不相同，多态有两种形式的多态，一种是静态多态，一种是动态多态。

静态多态。静态多态的设计思想：对于相关的对象类型，直接实现它们各自的定义，不需要共有基类，甚至可以没有任何关系。只需要各个具体类的实现中要求相同的接口声明，静态多态本质上就是模板的具现化。

动态多态。对于相关的对象类型，确定它们之间的一个共同功能集，然后在基类中，把这些共同的功能声明为多个公共的虚函数接口。各个子类重写这些虚函数，以完成具体的功能。具体实现就是c++的虚函数。

多态是以封装和继承为基础实现的性质，一个形态的多种表现方式。硬要解释的话可以说是一个接口，多个功能，在用父类指针调用函数时，实际调用的是指针指向的实际类型（子类）的成员函数。

c++多态有以下几种：

1. 重载。函数重载和运算符重载，编译期。

2. 虚函数。子类的多态性，运行期。

   在继承关系中，对于父类的方法我们也同样使用。但是正常来说，我们希望方法的行为取决于调用方法的对象，而不是指针或引用指向的对象有关。

3. 模板，类模板，函数模板。编译期

比如你家有亲属结婚了，让你们家派个人来参加婚礼，邀请函写的是让你爸来，但是实际上你去了，或者你妹妹去了，这都是可以的，因为你们代表的是你爸，但是在你们去之前他们也不知道谁会去，只知道是你们家的人。可能是你爸爸，可能是你们家的其他人代表你爸参加。这就是多态。

面向对象和面向过程语言的区别#

首要要知道这两个都是一种编程思想

面向过程就是分析出解决问题所需要的步骤，然后用函数把这些步骤一步一步实现，使用的时候一个一个依次调用就可以了。

面向对象是把构成问题事务分解成各个对象，建立对象的目的不是为了完成一个步骤，而是为了描叙某个事物在整个解决问题的步骤中的行为。

举一个例子：

例如五子棋，面向过程的设计思路就是首先分析问题的步骤：1、开始游戏，2、黑子先走，3、绘制画面，4、判断输赢，5、轮到白子，6、绘制画面，7、判断输赢，8、返回步骤2，9、输出最后结果。把上面每个步骤用分别的函数来实现，问题就解决了。

而面向对象的设计则是从另外的思路来解决问题。整个五子棋可以分为 1、黑白双方，这两方的行为是一模一样的，2、棋盘系统，负责绘制画面，3、规则系统，负责判定诸如犯规、输赢等。第一类对象（玩家对象）负责接受用户输入，并告知第二类对象（棋盘对象）棋子布局的变化，棋盘对象接收到了棋子的i变化就要负责在屏幕上面显示出这种变化，同时利用第三类对象（规则系统）来对棋局进行判定。

可以明显地看出，面向对象是以功能来划分问题，而不是步骤。同样是绘制棋局，这样的行为在面向过程的设计中分散在了总多步骤中，很可能出现不同的绘制版本，因为通常设计人员会考虑到实际情况进行各种各样的简化。而面向对象的设计中，绘图只可能在棋盘对象中出现，从而保证了绘图的统一。功能上的统一保证了面向对象设计的可扩展性。

面向过程

优点：性能比面向对象高，因为类调用时需要实例化，开销比较大，比较消耗资源;比如单片机、嵌入式开发、 Linux/Unix等一般采用面向过程开发，性能是最重要的因素。

缺点：没有面向对象易维护、易复用、易扩展

面向对象

优点：易维护、易复用、易扩展，由于面向对象有封装、继承、多态性的特性，可以设计出低耦合的系统，使系统 更加灵活、更加易于维护

缺点：性能比面向过程低

结构体(struct)和共同体(union)的区别#

结构体struct：把不同类型的数据组合成一个整体。struct里每个成员都有自己独立的地址。sizeof(struct)是内存对齐后所有成员长度的加和。（引申出内存对齐的问题）

共同体union：各成员共享一段内存空间, 一个union变量的长度等于各成员中最长的长度，以达到节省空间的目的。所谓的共享不是指把多个成员同时装入一个union变量内, 而是指该union变量可被赋予任一成员值,但每次只能赋一种值, 赋入新值则冲去旧值。 sizeof(union)是最长的数据成员的长度。

总结： struct和union都是由多个不同的数据类型成员组成, 但在任何同一时刻, union中只存放了一个被选中的成员, 而struct的所有成员都存在。在struct中，各成员都占有自己的内存空间，它们是同时存在的。一个struct变量的总长度等于所有成员长度之和。**在Union中，所有成员不能同时占用它的内存空间，它们不能同时存在。**Union变量的长度等于最长的成员的长度。对于union的不同成员赋值, 将会对其它成员重写, 原来成员的值就不存在了, 而对于struct的不同成员赋值是互不影响的。

struct的内存对齐规则#

为什么要字节对齐？

需要字节对齐的根本原因在于CPU访问数据的效率问题。假如没有字节对齐，那么一个double类型的变量会存储在4-11上（正常是0-7）这样计算机取这个数据的会会取两次，降低效率。而如果变量在自然对齐位置上，则只要一次就可以取出数据。一些系统对对齐要求非常严格，比如sparc系统，如果取未对齐的数据会发生错误。

对齐规则

由于在x86下，GCC默认按4字节对齐，但是可以使用__attribute__选项改变对齐规则， vs studio上用#pragma pack (n)方式改变

举例子：

1
//sizeof stu = 4 +4 + 12 = 20
2
struct stu{
3
    char sex;      //4
4
    int length;      //4
5
    char name[10];    //12
6
};
7

8
// size of str1 = 1 + 1+(2)+4 = 8
9
//两个char后需要再补充两个字节凑够4字节
10
struct node1
11
{
12
    char c1;
13
    char c2;
14
    int a;
15
}str1 ;
16

17
// 5+2+1+4 = 12
18
//char前4个元素占4字节，第5个元素和short一共3字节，需要补1个字节
19
struct str4  {
20
    char c1[5];
21
    short c;
22
    int b;
23
}str4 ;
24

25
// 1+(7)+8+1+(7) = 24
26
struct str6 {
27
    char c1;
28
    double a;
29
    char c2;
30
}str6 ;

易错点

1
//sizeof = 8
2
struct str{
3
    char p;
4
    int a;
5
    int b[0];
6
}
7

8
//sizeof = 4
9
struct str{
10
    int b[0];
11
}
12

13
//sizeof = 1
14
struct str{
15

16
}

上面三个结构体都包含空数组，空数组指的是长度为0的数组int[]或int[0]

这种定义只能在类或者结构体中定义，在外部是非法定义。空数组不占空间，也无需初始化

空数组名是一个指针，（但是又不占空间）指向一个位置；对于结构体，空数组名这个指针指向了前面一个成员结束的第一个空间。

不能再函数中定义Int a[0] 或int a[];这种

arr和&arr[0]和&arr的不同#

首先如果打印的话，三个打印的完全一样，都是数组首元素的地址。

首先&arr应该是整个元素的地址，但是打印出来却是首元素的地址，不同之处在于对地址做加法运算后有不同，如下：

1
int arr[10]={0};
2
printf("%p\n",arr);//首元素的地址
3
printf("%p\n",arr+1);
4

5
printf("%p\n",&arr[0]);//首元素的地址
6
printf("%p\n",&arr[0]+1);
7

8
printf("%p\n",&arr);//整个数组元素的地址
9
printf("%p\n",&arr+1);

输出首元素地址都是相同的，arr+1和&arr[0]+1都是只移动了4个字节，但是&arr+1移动了40个字节

结论：&arr代表的是整个数组的地址，虽然它具体表现为首个元素的地址，但是在对其进行操作时，是以整个数组为单位的。

补充

arr 本身是左值（但不可仅凭此表达式修改），指代数组对象。不过 arr 会在大多数场合隐式转换成右值表达式 &(arr[0]) ，为指针类型，指向 arr[0] 。&arr 是右值表达式，为指针类型，指向 arr 本身。简单来说就是 arr 本身不是地址而是指代整个数组，只不过会隐式转成指针罢了。

char a,char a[],char *a,char *[],char * *a 之间的区别#

1. char a

   定义了一个存储空间，存储的是char类型的变量

2. char a[]

   是一个字符数组，数组中的每一个元素是一个char类型的数据

3. char *a

   字符串的本质（在计算机眼中）是其第一个字符的地址，c和c++中操作字符串是通过内存中其存储的首地址来完成的

   对于char a[]来说a代表的是数组的首地址，那么对char *a来说a代表的也是字符串的首地址

   因此char a[]和char *a可以放到一块看，这两个没有本质区别。

   但是要注意对于char s[]和char* a我们可以有a=s，但不能有s=a，因为创建数组的时候s的地址不为空已经确定，但是a是一个空指针，不能将非空的地址指向空指针

4. char *a[]

   *的优先级是低于[]的，因此要先看a[]再看 *

   因此这是一个char数组，数组中的每一个元素都是指针，这些指针指向char类型

   char *a[ ] = {"China","French","America","German"}

5. char **a

   两个**代表相同的优先级，因此从右往左看，即char*(*a)

   char *a不就是一个字符串数组，a代表首地址。那么char * (*a)就是和char *a[]一样的数据结构

一维数组名和二维数组名的区别#

不管是一维还是多维数组，都是内存中一块线性连续空间，因此在内存级别上，其实都只是一维。

所以一维数组名是指向该数组的指针，二维数组名也是指向该数组的指针，但是+1之后，跳过的是一行。

问：二维数组名为什么不能直接赋值给二级指针？

答：一句话来说就是二维数组名是行指针，也就是指向数组的指针。而二级指针是指向指针的指针，它们不是同一类型。

定义一维数组 int a[i] 和二维数组 int b[i][j]，a相当于int (*)，而b相当于int (*)[j]。想要获得 a[i] 中第 x 个元素，可以直接使用 *(a+x)。而想要获得 b[i][j] 中第 x 行第 y 个元素，则需用 *(*(b+x)+y)，因为 b 相当于数组指针，(b+x) 则是指向第 x 个数组的指针，注意，是指向数组，而不是数组元素！所以 *(b+x) 获得的是第 x 个数组的数组名，即该数组的首元素地址，这时再结合偏移量 y 就可以取得该元素。

数组指针和指针数组#

其实就是数组的指针和指针的数组

数组的指针：指向一个数组的指针就是数组指针

指针的数组：一个数组的每一个元素都是指针

C++内存布局/程序分段#

也可以叫做进程逻辑地址空间

内存从上到下分别是：

• 栈stack |高地址|
• 堆heap
• bss段
• data段
• 代码段text |低地址|

栈：保存函数的局部变量，参数以及返回值。在函数调用后，系统会清楚栈上保存的栈帧和局部变量，函数参数等信息。栈是从高到低增长的。

堆：动态内存分配的都放在堆上。堆是从低到高的。

bss段：（Block Started by Symbol）存放程序中未初始化的全局变量的一块内存区域，在程序载入时由内核置为0。

data段：static变量和所有初始化的全局变量都在data段中。

bss段和data段都是静态内存分配，也就是说在编译的时候自动分配的。

bss和data段也有一种说法合起来叫数据段，有三种类型：

1. 只读数据段，常量与const修饰的全局变量
2. 可读可写数据段，存放初始化的全局变量和static变量
3. bss段，存放未初始化的全局变量

text段：代码段，text段在内存中被映射为只读，但.data和.bss是可写的。由编译器在编译连接时自动计算的，当你在链接定位文件中将该符号放置在代码段后，那么该符号表示的值就是代码段大小，编译连接时，该符号所代表的值会自动代入到源程序中。

static 和const分别怎么用，类里面static和const可以同时修饰成员函数吗#

• static

  • static对于变量

    1. 局部变量

       在局部变量之前加上关键字static，局部变量就被定义成为一个局部静态变量。

       内存中的位置：data段

       初始化：局部的静态变量只能被初始化一次

       作用域：作用域仍为局部作用域，当定义它的函数或者语句块结束的时候，作用域随之结束。

       当static用来修饰局部变量的时候，它就改变了局部变量的存储位置（从原来的栈中存放改为静态存储区）及其生命周期（局部静态变量在离开作用域之后，并没有被销毁，而是仍然驻留在内存当中，直到程序结束，只不过我们不能再对他进行访问），但未改变其作用域。

    2. 全局变量

       在全局变量之前加上关键字static，全局变量就被定义成为一个全局静态变量。

       内存中的位置：静态存储区（静态存储区在整个程序运行期间都存在）

       初始化：未经初始化的全局静态变量会被程序自动初始化为0

       作用域：全局静态变量在声明他的文件之外是不可见的。准确地讲从定义之处开始到文件结尾。(只能在本文件中存在和使用)

       全局变量本身就是静态存储方式， 静态全局变量当然也是静态存储方式。两者的区别在于非静态全局变量的作用域是整个源程序， 当一个源程序由多个源文件组成时，非静态的全局变量在各个源文件中都是有效的（在其他源文件中使用时加上extern关键字重新声明即可）。 而静态全局变量则限制了其作用域， 即只在定义该变量的源文件内有效， 在同一源程序的其它源文件中不能使用它。

  • static对于函数

    修饰普通函数，表明函数的作用范围，仅在定义该函数的文件内才能使用。在多人开发项目时，为了防止与他人命名空间里的函数重名，可以将函数定位为 static。（和全局变量一样限制了作用域而已）

  • static对于类

    1. 成员变量

       用static修饰类的数据成员实际使其成为类的全局变量，会被类的所有对象共享，包括派生类的对象。

       因此，static成员必须在类外进行初始化，而不能在构造函数内进行初始化。不过也可以用const修饰static数据成员在类内初始化 。

    2. 成员函数

       用static修饰成员函数，使这个类只存在这一份函数，所有对象共享该函数，不含this指针。

       静态成员是可以独立访问的，也就是说，无须创建任何对象实例就可以访问。

       不可以同时用const和static修饰成员函数。

• const

  1. const修饰变量：限定变量为不可修改。

  2. const修饰指针：指针常量和指向常量的指针

  3. const和函数：有以下几种形式

     1
     const int& fun(int& a); //修饰返回值
     2
     int& fun(const int& a); //修饰形参
     3
     int& fun(int& a) const{} //const成员函数

  4. const和类：①const修饰成员变量，在某个对象的声明周期内是常量，但是对于整个类而言是可以改变的。因为类可以创建多个对象，不同的对象其const成员变量的值是不同的。切记，不能在类内初始化const成员变量，因为类的对象没创建前，编译器并不知道const成员变量是什么，因此const数据成员只能在初始化列表中初始化。②const修饰成员函数，主要目的是防止成员函数修改成员变量的值，即该成员函数并不能修改成员变量。③const对象，常对象，常对象只能调用常函数。

  5. 限定成员函数不可以修改任何数据成员

• static和const可以同时修饰成员函数吗?

  答：不可以。C++编译器在实现const的成员函数的时候为了确保该函数不能修改类的实例的状态，会在函数中添加一个隐式的参数const this*。但当一个成员为static的时候，该函数是没有this指针的。也就是说此时const的用法和static是冲突的。两者的语意是矛盾的。static的作用是表示该函数只作用在类型的静态变量上，与类的实例没有关系；而const的作用是确保函数不能修改类的实例的状态，与类型的静态变量没有关系。因此不能同时用它们。

static初始化时机和线程安全问题#

先说在C语言中：

静态局部变量和全局变量一样，数据都存放在全局区域，所以在主程序之前，编译器已经为其分配好了内存，在编译阶段分配好了内存之后就进行初始化，在程序运行结束时变量所处的全局内存会被回收。所以在c语言中无法使用变量对静态局部变量进行初始化。

再说C++和C语言的区别：

c++主要引入了类这种东西，要进行初始化必须考虑到相应的构造函数和析构函数，而且很多时候构造或者析构函数中会指定我们定义的操作，并非简单的分配内存。因此为了造成不必要的影响（一些我不需要的东西被提前构造出来）所以c++规定全局或者静态对象在首次用到的时候才会初始化。

所以c++整了两种初始化的情况，我理解就是编译初始化和运行初始化。

编译初始化也叫静态初始化。对全局变量和const类型的初始化主要是，叫做zero initialization 和 const initialization，静态初始化在程序加载的过程中完成。从具体实现上看，zero initialization 的变量会被保存在 bss 段，const initialization 的变量则放在 data 段内，程序加载即可完成初始化，这和 c 语言里的全局变量静态变量初始化基本是一致的。其次全局类对象也是在编译器初始化。

动态初始化也叫运行时初始化。主要是指需要经过函数调用才能完成的初始化或者是类的初始化，一般来说是局部静态类对象的初始化和局部静态变量的初始化。

下面是我自己的实验的一段代码：

1
#include<stdio.h>
2
static int a;
3
int main()
4
{
5
  int b = 5;
6
  {
7
        //g++编译报错
8
     static int c = b;
9
        //gcc编译不报错
10
        static int c = b;
11
  }
12
  return 0;
13
}

如果在c语言中有局部静态变量赋值操作的话会报错：undefined reference to ' __cxa_guard_acquire'和 '__cxa_guard_release'。而这两个API接口恰恰是c++中保证局部静态变量运行时初始化的关键，具体参考c++局部静态变量和线程安全具体实现参考

线程安全问题：

C语言中非局部静态变量一般在main执行之前的静态初始化过程中分配内存并初始化，可以认为是线程安全的；C++11标准针规定了局部静态变量初始化是线程安全的。这里的线程安全指的是：一个线程在初始化 m 的时候，其他线程执行到 m 的初始化这一行的时候，就会挂起而不是跳过。

具体实现如下：局部静态变量在编译时，编译器的实现是和全局变量类似的，均存储在bss段中。然后编译器会生成一个guard_for_bar 用来保证线程安全和一次性初始化的整型变量，是编译器生成的，存储在 bss 段。它的最低的一个字节被用作相应静态变量是否已被初始化的标志， 若为 0 表示还未被初始化，否则表示已被初始化( if ((guard_for_bar & 0xff) == 0)判断)。 __cxa_guard_acquire 实际上是一个加锁的过程， 相应的 __cxa_guard_abort 和 __cxa_guard_release 释放锁。

1
void foo() {
2
    static Bar bar;
3
}
4

5
//gcc 4.8.3 编译器生成的汇编代码
6
void foo() {
7
    if ((guard_for_bar & 0xff) == 0) {
8
        if (__cxa_guard_acquire(&guard_for_bar)) {
9
            try {
10
                Bar::Bar(&bar);
11
            } catch (...) {
12
                __cxa_guard_abort(&guard_for_bar);
13
                throw;
14
            }
15
            __cxa_guard_release(&guard_for_bar);
16
            __cxa_atexit(Bar::~Bar, &bar, &__dso_handle);
17
        }
18
    }
19
    // ...
20
}

C++中局部静态变量的问题#

1
int tmp(){
2
    static int b = 5;
3
    return b;
4
}
5
int main(){
6
    static int a = 0;
7
    int c = tmp();
8
    std::cout<<"a:"<<a<<std::endl;
9
    std::cout<<"c:"<<c<<std::endl;
10
}

Const与指针#

只有两种情况：指向常量的指针和常量指针

指向常量的指针表明不能通过解除引用运算符去改变其值，指向的变量是常量

常量指针表明初始化后的指针指向的地址是不能改变的，但这块地址上的存储的值可以改变，地址跟随一生。所以p2= &a是错误的，而*p2 = a 是正确的。

1
const int p     //p为常量，初始化后不能更改
2
const int *p  //*p为常量，不能通过*p改变其内容
3
int const *p  //同上
4
int *const p  //常量指针

指针和引用的区别#

关于引用的本质可以看这个

引用的底层本质：

从高级语言层面的概念来说：引用是变量的别名，它不能脱离被引用对象独立存在。接下来看一下底层引用到底是什么？

1
//一段引用的代码
2
int i=5;
3
int &ri=i;
4
ri=8;
5

6
//上述代码对应的汇编代码
7
int i=5;
8
00A013DE  mov        dword ptr [i],5      //将文字常量5送入变量i
9

10
//这一步是引用的初始化过程，对于引用十分重要
11
int &ri=i;
12
00A013E5  lea        eax,[i]             //将变量i的地址送入寄存器eax
13
00A013E8  mov        dword ptr [ri],eax    //将寄存器的内容（也就是变量i的地址）送入变量ri
14

15
ri=8;
16
00A013EB  mov        eax,dword ptr [ri]    //将变量ri的值送入寄存器eax
17
00A013EE  mov        dword ptr [eax],8     //将数值8送入以eax的内容为地址的单元中
18
return 0;
19
00A013F4  xor        eax,eax

可以看到在汇编代码中ri这个引用的数据类型是dword(double word-4字节)。所以ri确实是一个变量，存放的是被引用的对象的地址。指针和引用的区别要看下一段代码：

1
//一段常量指针的代码
2
int i=5;
3
int* const pi=&i;
4
*pi=8;
5

6
//上述代码对应的汇编代码
7
int i=5;
8
011F13DE  mov         dword ptr [i],5
9

10
int * const pi=&i;
11
011F13E5  lea         eax,[i]
12
011F13E8  mov         dword ptr [pi],eax
13

14
*pi=8;
15
011F13EB  mov         eax,dword ptr [pi]
16
011F13EE  mov         dword ptr [eax],8

可以看到引用和常量指针的汇编代码是一模一样的，所以可以得出在底层，引用就是一个常量指针。

高级语言层面引用与指针常量的关系

1. 相同点：指针和引用在内存中都占用4个或者8个字节的存储空间，都必须在定义的时候给初始化。

2. 指针常量本身（以p为例）允许寻址，即&p返回指针常量本身的地址，*p表示被指向的对象

   引用变量本身（以r为例）不允许寻址，&r返回的是被引用对象的地址，而不是变量r的地址(r的地址由编译器掌握，程序员无法直接对它进行存取)

3. 引用不能为空，指针可以为空；

4. 指针数组这一块。数组元素允许是指针但不允许是引用，主要是为了避免二义性。假如定义一个“引用的数组”，那么array[0]=8;这条语句该如何理解？是将数组元素array[0]本身的值变成8呢，还是将array[0]所引用的对象的值变成8呢?

5. 在C++中，指针和引用经常用于函数的参数传递，然而，指针传递参数和引用传递参数是有本质上的不同的：指针传递参数本质上是值传递的方式，它所传递的是一个地址值。值传递的特点是被调函数对形式参数的任何操作都是作为局部变量进行，不会影响主调函数的实参变量的值。而在引用传递过程中， 被调函数的形参虽然也作为局部变量在栈中开辟了内存空间，但是这时存放的是由主调函数放进来的实参变量的地址（指针放的是实参变量地址的副本）。

6. “sizeof引用”得到的是所指向的变量(对象)的大小，而”sizeof指针”得到的是指针本身的大小；

用const和#define定义常量哪个更好？#

#define宏常量和const常量的区别#

类型和安全检查不同

宏定义是字符替换，没有数据类型的区别，同时这种替换没有类型安全检查，可能产生边际效应等错误；

const常量是常量的声明，有类型区别，需要在编译阶段进行类型检查

编译器处理不同

宏定义是一个”编译时”概念，在预处理阶段展开，不能对宏定义进行调试，生命周期结束与编译时期；

const常量是一个”运行时”概念，在程序运行使用，放在内存中的data段中。

存储方式不同

宏定义是直接替换，不会分配内存，存储于程序的代码段中；

const常量需要进行内存分配，存储于程序的数据段中

是否可以做函数参数

宏定义和const常量可以在函数的参数列表中出现

typedef与#define的区别#

typedef

typedef故名思意就是类型定义的意思，但是它并不是定义一个新的类型而是给已有的类型起一个别名。主要有两个作用，第一个是给一些复杂的变量类型起别名，起到简化的作用。第二个是定义与平台无关的类型，屏蔽不同平台之间的差异。在跨平台或操作系统的时候，只需要改typedef本身就可以

#define

#define为一宏定义语句，本质就是文本替换

区别

1. 关键字typedef在编译阶段有效，由于是在编译阶段，因此typedef有类型检查的功能。#define则是宏定义，发生在预处理阶段，也就是编译之前，它只进行简单而机械的字符串替换，而不进行任何检查。

2. #define没有作用域的限制，只要是之前预定义过的宏，在以后的程序中都可以使用。而typedef有自己的作用域。

3. 对指针操作不同。见下面代码

1
typedef int * pint;
2
#define PINT int *
3

4
int i1 = 1, i2 = 2;
5

6
const pint p1 = &i1;  //p不可更改，p指向的内容可以更改，相当于 int * const p;
7
const PINT p2 = &i2;  //p可以更改，p指向的内容不能更改，相当于 const int *p；或 int const *p；

#include<>和#include“ ”的区别#

#include<>

一般用来查找标准库文件所在目录，在编译器设置的include路径内搜索；

#include""

#include "" 的查找位置是当前源文件所在目录

要注意的一点就是，如果我们自己写的头文件，而不是标准库函数中的，那么引用这个头文件要使用#include""，而不能使用#include<>，因为我们自己写的头文件并不在编译器设置的路径内，使用#include<>会提示无法找到。

若 #include "" 查找成功，则遮蔽 #include <> 所能找到的同名文件；否则再按照 #include <> 的方式查找文件。

左值和右值#

对于左值和右值写的很详细

左值引用和右值引用#

1
//左值引用
2
int a = 10;
3
int &b = a;  // 定义一个左值引用变量
4
b = 20;      // 通过左值引用修改引用内存的值
5

6
//常量左值引用
7
const int temp = 10;
8
const int &var = temp;

1
int i = getVar();
2
auto f = []{return 5;};

1
T&& k = getVar();

1
T(T&& a){
2
  m_val = a.m_val;
3
  a.m_val=nullptr;
4
}

1
template <typename T>
2
void f(T&& val){
3
  foo(std::forward<T>(val));
4
}
5

6
//模板类会出现的问题
7
template <typename T>
8
void forwardValue(T& val)
9
{
10
    processValue(val); //右值参数会变成左值
11
}
12
template <typename T>
13
void forwardValue(const T& val)
14
{
15
    processValue(val); //参数都变成常量左值引用了
16
}

深拷贝和浅拷贝#

在未定义显示拷贝构造函数的情况下，系统会调用默认的拷贝函数——即浅拷贝，它能够完成成员的一一复制。

当数据成员中没有指针时，浅拷贝是可行的；

**但当数据成员中有指针时，会出问题。如果没有自定义拷贝构造函数，会调用默认拷贝构造函数，这样就会调用两次析构函数。**第一次析构函数delete了内存，第二次的就指针悬挂了。所以，此时，必须采用深拷贝。

深拷贝与浅拷贝的区别就在于深拷贝会在堆内存中另外申请空间来储存数据，从而也就解决了指针悬挂的问题。简而言之，当数据成员中有指针时，必须要用深拷贝。

O0、O1、O2、O3优化#

-O0

不做任何优化，这是默认的编译选项。

-O1

主要对代码的分支、常量以及表达式进行优化。会减小代码的尺寸，缩短执行周期啥的

-floop-optimize：执行循环优化,将常量表达式从循环中移除，简化判断循环的条件，并且optionally do strength-reduction，或者将循环打开等。在大型复杂的循环中，这种优化比较显著。

-O2

O2优化再打开O1优化的前提下，尝试更多的寄存器级的优化以及指令级的优化，它会在编译期间占用更多的内存和编译时间。

所以一般来说可以直接开-O2的优化等级，

-O3

在O2的基础上进行更多的优化，例如使用伪寄存器网络，普通函数的内联，以及针对循环的更多优化。

这个好像不推荐，因为会增加编译失败和程序不可预知的一些行为，不建议使用

c++中四种变量存储类型总结#

在C++语言中，变量的存储类共有如下四种：

（1）auto存储类（自动存储类）

（2）static存储类 （静态存储类）

（3）extern存储类 (外部存储类)

（4）register存储类（寄存器存储类）

• 自动存储类

  auto存储类，即自动存储类。在函数内部定义的变量，如果不指定其存储类，那么它就是auto类变量。这个是最常见的，所以我们不加关键字auto

  这是我们经常见到的一种变量存储类型。见如下代码：

  1
  void func( ) { int a; auto int b; … }
  2
  //a和b都是auto存储类变量

  自动存储类在在进入代码块（函数）之前生成，在函数体内部存活，出了函数体（函数返回）后就消失。

  自动变量默认初始值是不确定的、

  自动存储类每调用一次函数时都要赋一次初始值

• 静态存储类

  static关键字在c和c++中是不同的，这个在上面说过了，具体的话可以去看上面。

• extern存储类

  如果在一个文件中要引用另一个文件中定义的外部变量，则在此文件中应用extern关键字把此变量说明为外部的。例如：

  1
  extern int a; //a为别的文件中定义的外部变量
  2
  int mydata; //外部变量的定义
  3
  extern int mydata;  //外部变量的说明

  大型程序为了易于维护和理解，通常需要把程序划分为多个文件来保存，每个文件都可以单独编译，最后再把多个文件的编译结果（即目标文件）连接到一起来生成一个可执行程序。这种情况下，如果在一个文件中需要引用另一个文件中的外部变量，就需要利用extern说明。

• register存储类

  为了提高某些自动类变量或函数参数的处理速度，可以在定义这些变量的类型说明符的前面加上register关键字，以通知编译系统为这些变量分配寄存器来存放其值。若使用register（而非auto）存储类标识代码块内的变量，编译器就会将变量缓存于处理器内的寄存器中，此种情况下不能对该变量或其成员变量使用引用操作符&以获取其地址，因为&只能获取内存空间中的地址

C++中this指针相关问题#

inline 内联函数与宏定义#

首先分析一下C宏定义的好处：首先C语言是一个效率很高的语言，使用预处理器实现，没有参数压栈，函数返回等操作，效率很高。

1. 相当于把内联函数里面的代码写在调用内联函数处。不用执行进入函数的步骤，直接执行函数体。

2. 从上面那一条的角度说，内联函数更像是宏，但却比宏多了类型检查，真正具有函数特性。

3. 在类声明中定义的函数，除了虚函数的其他函数都会自动隐式地当成内联函数。

4. 编译器会为所用 inline 函数中的局部变量分配内存空间

5. 会将 inline 函数的的输入参数和返回值映射到调用方法的局部变量空间中；

• 优点

  • 内联函数同宏函数一样将在被调用处进行代码展开，省去了参数压栈、栈帧开辟与回收，结果返回等，从而提高程序运行速度。
  • 内联函数相比宏函数来说，在代码展开时，会做安全检查或自动类型转换（同普通函数），而宏定义则不会。
  • 内联函数在运行时可调试，而宏定义不可以。
  • 可以说inline函数不仅吸收了了C宏定义的，同时消除宏定义的缺点。

• 缺点

  • 代码膨胀。内联是以代码膨胀（复制）为代价，消除函数调用带来的开销。
  • inline 函数无法随着函数库升级而升级。inline函数的改变需要重新编译。
  • 万一又递归调用，代码量很大。

• 虚函数（virtual）可以是内联函数（inline）吗？

• 首先要明白，内联函数是编译器做出的选择，是否内联决定权在编译器，程序员不可控。同时，虚函数是多态性的一种体现，多态性表现在函数的运行阶段而不是函数的编译阶段。因此，虚函数表现为多态性时（运行期）不可以内联。

• 唯一可以内联的时候是：编译器知道所调用的对象是哪个类。只有在编译器具有实际对象而不是对象的指针或引用时才会发生。

inline说明对编译器来说只是一种建议，编译器可以忽略这个建议的，比如，你将一个长达100多行的函数指定为inline，编译器就会自动忽略这个inline，将这个函数还原成普通函数。在调用内联函数时，要保证内联函数的定义让编译器看到，也就是说，内联函数inline必须要定义在头文件中，这与通常的函数定义是不一样的。

struct 和 typedef struct#

1
/代码1（c语言）
2
typedef struct test3{
3
  int a;
4
  int b;
5
  int c;
6
}test4;
7
//代码2（c++）
8
struct test3{
9
  int a;
10
  int b;
11
  int c;
12
}test4;

• 在c语言中

  对于代码1。test3相当于标识符，而test4相当于变量类型.定义一个结构体变量为test4 t，即struct test3 = test4

  对于代码2。要定义结构体变量必须写成struct test3 t

• 在c++中

  对于代码1。不要这样写，基本上是代码二的类型。test4变成了变量名

  对于代码2 。这是c++的写法，test4相当于一个结构体变量。

explicit 关键字#

explicit关键字主要是用来修饰类中的构造函数的，对于仅有一个参数或除第一个参数外其余参数均有默认值的类构造函数，尽可能使用explicit关键字修饰。因为只有一个参数或者出了第一个参数其他参数是默认参数的构造函数来说，他还有另一个名字叫做转换构造函数。

**所以explicit主要用来防止隐式转换。**因为仅含一个参数的构造函数和除了第一个参数外其余参数都有默认值的多参构造函数承担了两个角色。 第一个是成为带参数的构造函数，第二个是一个默认且隐含的类型转换操作符（就是单参数的构造函数是一种隐含的类型转换符）

额外说一下隐式类型转换：

c++隐式类型转换是指c++自动将一种类型转换成另一种类型，是编译器的一种自主行为。

举一些类型转换的例子：

1
int i=3;
2
double j = 3.1;
3
i+j;//i会被转换成double类型，然后才做加法运算。
4

5
class A{};
6
class B: public A
7
{};//B是子类
8
void Fun(A& a);
9
B b;
10
Fun(b);//使用子类对象代替父类对象是可以的，也是因为隐式类型转换。
11

12
class Test
13
{
14
  public:
15
    Test(int i);
16
};
17

18
Test t1 = 1;//正确，由于强制类型转换，1先被Test构造函数构造成Test对象，然后才被赋值给t1
19
Test t2(1);//正确

friend友元类和友元函数#

看这里

采用类的机制后实现了数据的隐藏与封装，类的数据成员一般定义为私有成员，成员函数一般定义为公有的，依此提供类与外界间的通信接口。有时需要定义一些函数，这些函数不是类的一部分，但又需要频繁地访问类的数据成员，这时可以将这些函数定义为该函数的友元函数。如果不用友元你可以使用成员函数来set这些数据成员。

除了友元函数外，还有友元类，两者统称为友元。

友元函数能够使得普通函数直接访问类的保护数据和私有数据成员，避免了类成员函数的频繁调用，可以节约处理器开销，提高程序的效率，但所矛盾的是，即使是最大限度大保护，同样也破坏了类的封装特性，这即是友元的缺点，在现在cpu速度越来越快的今天我们并不推荐使用它。

友元类友元类的所有成员函数都是另一个类的友元函数，都可以访问另一个类中的隐藏信息（包括私有成员和保护成员）。

友元的作用是提高了程序的运行效率（即减少了类型检查和安全性检查等都需要时间开销），但它破坏了类的封装性和隐藏性，使得非成员函数可以访问类的私有成员。

我碰到了一种必须使用友元的情况。如下图

上述代码由于使用了priority_queue，而且每个成员是一个结构体，所以需要重新定义std::less的比较方式，所以在结构体重重载了<号，这个时候重载运算符需要用到友元。因为std::less类中的比较运算符需要调用struct中的，因此需要把结构体中的设置为友元。

c++虚函数#

1
BrassPlus dilly;
2
Brass *pb = &dilly;
3
Brass &pb = dilly;

虚函数工作原理#

c++没有强制规定虚函数的实现方式。编译器中主要用虚表指针（vptr）和虚函数表（vtbl）来实现的

先直接上图，然后再看一下虚函数的执行过程：

当调用一个对象对应的函数时，通过对象内存中的vptr找到一个虚函数表（注意这虚函数表既不在堆上，也不再栈上）。虚函数表内部是一个函数指针数组，记录的是该类各个虚函数的首地址。然后调用对象所拥有的函数。

C语言怎么实现多态#

c++的多态分为两种：

1. 编译时多态：重载

2. 运行时多态：重写即虚函数。虚函数本身其实就是回调函数

思路就是使用函数指针来实现多态。

编译时多态：

先说一个c中的宏，__V_ARGS__，是c99引入进来的可变参宏，一般是用来输出debug信息。可以用这个宏实现一个简单的多态机制。代码举例：

1
#define Check(...) printf(__VA_ARGS__);
2
int main(int argc, char *argv[])
3
{
4
    int i = 1, j = 2;
5
    char *Error = "error!!";
6
    Check("i = %d\n", j);
7
    Check("i = %d, j = %d\n", i, j);
8
    Check("i = %d, j = %d, Error:%s\n", i, j, Error);
9
  return 0;
10
}
11
/*********************关于结构体的*****************************/
12
#define func(...) myfunc((struct mystru) { __VA_ARGS__})
13

14
struct mystru
15
{
16
    const char *name;
17
    double d;
18
    int number;
19
};
20

21
void myfunc(struct mystru ms)
22
{
23
    printf("%s, %lf, %d\n", ms.name, ms.d, ms.number);
24
}
25

26
int main(int argc, char *argv[])
27
{
28
    func();
29
    func("hello", 1.1);
30
    func("hello");
31
    func("hello", 1.1, 100);
32
    func(.name = "hello");
33
    func(.d = 1.1);
34
    func(.number = 100);
35
    func(.d = 1.1, .name = "hello");
36
  return 0;
37
}

注意：一般我们在使用结构体的时候都是先赋值在传参数，这里实际上是用”…”可变参数替换为了__VA_ARGS__这个宏，然后转化为(struct mystru){ __VA_ARGS__ }，其实就是 (struct mystru){ ... } 。 通过（struct mystru）把参数转化结构体，这也是为什么如果我们不指定.name或者是.number时，必须按顺序传递参数，否则报错，因为在内存中结构体布局是确定的。不明确指定哪个参数只能按顺序传递。

运行时多态：

在c中sizeof(struct)是0,从内存上来看，c++的class和struct不仅仅有数据还有成员函数，这些成员函数如果是non-inline的，那么只会在内存中产生一份实例供所有对象使用，如果是inline的，会为每一个使用着产生一个实例。而c的struct就简单多了，它不占用内存空间，每一个实例按照struct分配一份就好，但这也是问题所在，它在内存中没实例啊。那么用c的struct实现时，我们就要想办法让它在内存中存在一份，大家都能找到它。

所以主要关键点就是在于函数指针的使用

1
//虚函数表结构
2
struct base_vtbl
3
{
4
  void(*dance)(void *);
5
  void(*jump)(void *);
6
};
7

8
//基类
9
struct base
10
{
11
    /*virtual table*/
12
  struct base_vtbl *vptr;
13
};
14
//基类的构造函数
15
struct base * new_base()
16
{
17
    struct base *temp = (struct base *)malloc(sizeof(struct base));
18
    //基类虚表结构中函数指针具体关联的函数名
19
  temp->vptr->dance = base_dance;
20
    temp->vptr->jump = base_jump;
21
  return temp;
22
}
23
//基类的成员函数
24
void base_dance()
25
{
26
  printf("base dance\n");
27
}
28
void base_jump()
29
{
30
  printf("base jump\n");
31
}
32

33

34
//派生类
35
struct derived1
36
{
37
  struct base super;
38
  int high;
39
};
40
//派生类的构造函数
41
struct derived1 * new_derived1(int h)
42
{
43
    struct derived1 * temp= (struct derived1 *)malloc(sizeof(struct derived1));
44
    //派生类虚表结构中函数指针具体关联的函数名
45
  temp->super->vptr->dance = derived1_table;
46
    temp->super->vptr->jump = derived1_jump;
47
  temp->high = h;
48
  return temp;
49
}
50
//派生类对象成员函数
51
void derived1_dance()
52
{
53
  printf("derived1 dance\n");
54
}
55
void derived1_jump(void * this)
56
{
57
  struct derived1* temp = (struct derived1 *)this;
58
  printf("derived1 jump:%d\n", temp->high);
59
}
60

61
/*******实际调用***********/
62
 struct base * bas = new_base();
63
//这里调用的是基类的成员函数
64
bas->vptr->dance();
65
bas->vptr->jump();
66

67
struct derived1 * child = new_derived1(100);
68
//基类指针指向派生类
69
bas  = (struct base *)child;
70

71
//这里调用的其实是派生类的成员函数
72
bas->vptr->dance();
73
bas->vptr->jump((void *)bas);

抽象基类-纯虚函数#

定义纯虚函数是为了实现一个接口，起到一个规范的作用，规范继承这个类的程序员必须实现这个函数。

有纯虚函数的类叫做抽象基类，对于抽象类来说，C++是不允许它去实例化对象的。也就是说，抽象类无法实例化对象

C++ 纯虚基类函数=0#

“=0”这个操作在虚函数中有2层意思，即告诉编译器：

1. 有的朋友误解这是返回值为0的意思，但是它并不是，它仅表示的是这个是个纯虚函数，是个抽象函数，没有实现
2. 这个类的继承类里面必须要实现这个函数。

如何定义一个只能在堆上（栈上）生成对象的类?#

综述：在c++中，建立对象有两种方式，分为静态建立和动态建立，如代码所示：

1
//静态建立
2
A a;
3
//动态建立
4
A *a = new A;

静态建立对象时，由编译器自动为对象在栈中分配内存，是直接移动栈顶指针，腾出适当的空间，然后再这片空间上调用构造函数生成对象，这种静态建立是直接调用类的构造函数。

动态建立对象时，程序员使用new 运算符在堆中建立。这个过程分为两步，第一部是调用operator new()函数在堆空间中搜索出来适当的内存并进行分配，第二步是调用构造函数生成对象，初始化这片内存空间，间接调用构造函数。

• 只能在堆上生成对象的类。

  只能在堆上也就意味着不能再栈上，在栈上是编译器分配内存空间，构造函数来构造栈对象。在栈上当对象周期完成，编译器会调用析构函数来释放栈对象所占的空间，也就是说编译器管理了对象的整个生命周期。编译器在调用构造函数为类的对象分配空间时，会先检查析构函数的访问性，不光是析构函数，编译器会检查所有非静态函数的访问性。因此，如果类的析构函数是私有的，编译器不会为对象在栈上分配内存空间。

  扩展一下，如果把析构函数写在private中的话，不能用A a这种静态方式建立对象。但也会有其他问题，如果这个类是父类的话，通常要将析构函数加上virtual关键字，然后再子类重写，实现多态性。但是子类不能访问private成员，可以使用protected，子类可以访问父类的protected成员，但不能访问private。

  另一个问题，当用new建立后，无法delete。因为delete会调用对象的析构函数，但是析构函数在类外无法访问。可以这样写：

  1
  class  A
  2
  {
  3
  protected :
  4
      A(){}
  5
      ~A(){}
  6
  public :
  7
      static  A* create()
  8
      {
  9
          return  new  A();
  10
      }
  11
      void  destory()
  12
      {
  13
          delete  this ;
  14
      }
  15
  };

  展开收起

• 只能在栈上生成对象的类。

  只有使用new运算符才会在堆上创建对象。设为私有即可。

  动态建立类对象，是使用new运算符将对象建立在堆空间中。这个过程分为两步，第一步是执行operator new()函数，在堆空间中搜索合适的内存并进行分配；第二步是调用构造函数构造对象，初始化这片内存空间（这种方法，间接调用类的构造函数），但是operator new()函数用于分配内存，无法提供构造功能，所以不能将构造函数设为私有；

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

C++如何阻止类被实例化？#

为什么要组织实例化？

一个类不想被实例化通常有两种情况：一种是抽象类，一种是工具类。

抽象类

比如现在需要计算图形的面积，可以是正方形、长方形、圆形等等。于是抽象出了基类，叫图形。这部分抽象的没办法实例化，如：

1
class Sharp{};
2

3
class Circle : public Sharp{};
4

5
class Rectangle : public Sharp{};

工具类

我们需要一个类来封装加、减、乘、除。这个类就是一个典型的工具类，用它创建对象没有意义，可以直接通过类名调用静态成员函数。

1
class Calculate
2
{
3
public:
4
    static int add(int x, int y);
5
    static int sub(int x, int y);
6
    static int mul(int x, int y);
7
    static int div(int x, int y);
8
};

1
class Sharp
2
{
3
public:
4
    virtual void get_s() = 0;    //纯虚函数
5
};

1
class Calculate
2
{
3
private:
4
    Calculate();
5
public:
6
    static int add(int x, int y);
7
    static int sub(int x, int y);
8
    static int mul(int x, int y);
9
    static int div(int x, int y);
10
};

C++所有构造函数#

类对象被创建时，编译器为对象分配内存空间，并自动调用构造函数，由构造函数完成成员的初始化工作。

因此构造函数的的作用是初始化对象的成员函数。

**默认构造函数：**如果没有人为构造函数，则编译器会自动默认生成一个无参构造函数。

**一般构造函数：**包含各种参数，一个类可以有多个一般构造函数，前提是参数的个数和类型和传入参数的顺序都不相同，根据传入参数调用对应的构造函数。

**拷贝构造函数：**拷⻉构造函数的函数参数为对象本身的引用，用于根据⼀个已存在的对象复制出⼀个新的该类的对象，⼀般在函数中会将已存在的对象的数据成员的值⼀⼀复制到新创建的对象中。如果没有显示的写拷⻉构造函数，则系统会默认创建⼀个拷⻉构造函数，但当类中有指针成员时，最好不要使⽤编译器提供的默认的拷⻉构造函 数，最好⾃⼰定义并且在函数中执⾏深拷⻉。

**移动构造函数：**有时候我们会遇到这样一种情况，我们用对象a初始化对象b后对象a我们就不在使用了，但是对象a的空间还在呀（在析构之前），既然拷贝构造函数，实际上就是把a对象的内容复制一份到b中，那么为什么我们不能直接使用a的空间呢？这样就避免了新的空间的分配，大大降低了构造的成本。这就是移动构造函数设计的初衷。拷贝构造函数中，对于指针，我们一定要采用深层复制，而移动构造函数中，对于指针，我们采用浅层复制。

但是指针的浅层复制是非常危险的。浅层复制之所以危险，是因为两个指针共同指向一片内存空间，若第一个指针将其释放，另一个指针的指向就不合法了（pointer dangling）。所以我们只要避免第一个指针释放空间就可以了。避免的方法就是将第一个指针（比如a->value）置为NULL，这样在调用析构函数的时候，由于有判断是否为NULL的语句，所以析构a的时候并不会回收a->value指向的空间（同时也是b->value指向的空间）

赋值构造函数：=运算符的重载，类似拷贝构造函数，将=右边的类对象赋值给类对象左边的对象，不属于构造函数，=两边的对象必须都要被创建。

**类型转换构造函数：**有时候不想要隐式转换，用explict关键字修饰。一般来说带一个参数的构造函数，或者其他参数是默认的构造函数

什么情况下会调用拷贝构造函数？#

1. 对象以值传递的方式进入函数体
2. 对象以值传递的方式从函数返回
3. 一个对象需要另外一个对象初始化

为什么拷贝构造函数必须是引用？#

为了防止递归调用。

如果不用引用，就会是值传递的方式，但是值传递会调用拷贝构造函数生成临时对象，从而又调用一次拷贝构造函数。就这样无穷的递归下去。

如果是指针类型

就变成了一个带参数的构造函数了。。。

比如A(A* test)

构造函数析构函数是否能抛出异常#

构造函数可以抛出异常

对象只有在构造函数执行完成之后才算构造妥当，c++只会析构已经完成的对象。因此如果构造函数中发生异常，控制权就需要转移出构造函数，执行异常处理函数。在这个过程中系统会认为对象没有构造成功，导致不会调用析构函数。在构造函数中抛出异常会导致当前函数执行流程终止，在构造函数流程前构造的成员对象会被释放，但是如果在构造函数中申请了内存操作，则会造成内存泄漏。另外，如果有继承关系，派生类中的构造函数抛出异常，那么基类的构造函数和析构函数可以照常执行的。

解决办法：用智能指针来管理内存就可以

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

C++异常处理模型最大的特点和优势就是对C++中的面向对象提供了最强大的无缝支持。那么如果对象在运行期间出现了异常，C++异常处理模型有责任清除那些由于出现异常所导致的已经失效了的对象(也即对象超出了它原来的作用域)，并释放对象原来所分配的资源， 这就是调用这些对象的析构函数来完成释放资源的任务，所以从这个意义上说，析构函数已经变成了异常处理的一部分。

析构函数不能抛出异常原因有两个：

1. 如果析构函数抛出异常，则异常点之后的程序不会执行，如果析构函数在异常点之后执行了某些必要的动作比如释放某些资源，则这些动作不会执行，会造成诸如资源泄漏的问题。
2. 异常发生时，c++的异常处理机制在异常的传播过程中会进行栈展开（stack-unwinding）。在栈展开的过程中就会调用已经在栈构造好的对象的析构函数来释放资源，此时若其他析构函数本身也抛出异常，则前一个异常尚未处理，又有新的异常，会造成程序崩溃。

解决办法：把异常完全封装在析构函数内部，决不让异常抛出函数之外，代码如下：

1
DBConn::~DBconn()
2
{
3
    try
4
    {
5
      db.close();
6
    }
7
    catch(...)
8
    {
9
        abort();
10
    }
11
}
12
//如果close抛出异常就结束程序，通常调用abort完成：

创建派生类对象，构造函数的执行顺序是什么？析构函数的执行顺序？#

首先要知道类的构造函数不能被继承，构造函数不能被继承是有道理的，因为即使继承了，它的名字和派生类的名字也不一样（构造函数名字和类名一样），不能成为派生类的构造函数，当然更不能成为普通的成员函数。在设计派生类时，对继承过来的成员变量的初始化工作也要由派生类的构造函数完成，但是大部分基类都有private属性的成员变量，它们在派生类中无法访问，更不能使用派生类的构造函数来初始化。这种矛盾在C++继承中是普遍存在的，解决这个问题的思路是：在派生类的构造函数中调用基类的构造函数。

对象创建时候执行顺序是：**静态代码 —> 非静态代码 —> 构造函数。**静态代码包括（静态方法，静态变量，静态代码块等），非静态代码即（成员方法，成员变量，成员代码块等）。代码块中或者成员变量中如果有类对象的话，肯定要先将类对象创建出来。所以说先执行代码块再执行构造函数，而且如果代码块中有多个成员变量，则按照成员变量的声明顺序进行构造。初始化列表的顺序, 不影响成员变量构造顺序

因为静态变量等这些在内存中属于全局变量，所以要先创建。然后类会查看成员函数的相关信息，为该类的对象中的每个成员变量分配相应的存储空间，然后再执行构造函数创建对象，如果构造函数有初始化，则将值放到准备好的内存空间中。

构造函数执行顺序

1. 基类构造函数。如果有多个基类，则构造函数的调用顺序是该基类在派生类中出现的顺序，而不是他们在成员初始化列表中的顺序。
2. 成员类对象构造函数。如果有多个成员类构造函数调用顺序是对象在类中被声明的顺序，而不是他们在成员初始化列表中的顺序
3. 派生类构造函数

析构函数顺序

1. 派生类析构函数
2. 成员类对象的析构函数
3. 调用基类的析构函数

C++成员变量的初始化顺序问题#

1
class A
2
{
3
private:
4
    int n1;
5
    int n2;
6
public:
7
    A():n2(0),n1(n2+2){}
8
    void Print(){
9
        cout << "n1:" << n1 << ", n2: " << n2 <<endl;
10
    }
11
};
12

13
int main()
14
{
15
    A a;
16
    a.Print();
17
    return 1;
18
}
19

20
//输出：n1: 是一个随机数；n2: 0
21
//有的编译器是n1:2, n2=0

1. 成员变量在使用初始化列表初始化时，只与定义成员变量的顺序有关，与构造函数中初始化成员列表的顺序无关。因为成员变量的初始化次序是根据变量在内存中次序有关，而内存中的排列顺序早在编译期就根据变量的定义次序决定了。
2. 如果不使用初始化列表初始化，在构造函数内初始化时，此时与成员变量在构造函数中的位置有关。
3. 类成员在定义时，是不能初始化的
4. 类中const成员常量必须在构造函数初始化列表中初始化。
5. 类中static成员变量，必须在类外初始化。

变量的初始化顺序：

1. 初始化基类中的静态成员变量和静态代码块，按照在程序中出现的顺序初始化；
2. 初始化派生类中的静态成员变量和静态代码块，按照在程序中出现的顺序初始化；
3. 初始化基类的普通成员变量和代码块，再执行父类的构造方法；
4. 初始化派生的普通成员变量和代码块，在执行子类的构造方法；

c++的public、private、protected继承特点#

什么不能被继承？#

1、构造函数

构造函数不能被继承第一个原因：在创建派生类对象时必须调用派生类的构造函数。派生类构造函数通常使用成员列表初始化来调用基类构造函数以创建派生类中的基类部分。如果派生类没有使用成员列表初始化语法，则将使用默认的基类构造函数，如果基类没有默认的构造函数就会报错。第二个原因：因为即使继承了，它的名字和派生类的名字也不一样（构造函数名字和类名一样），不能成为派生类的构造函数，当然更不能成为普通的成员函数。在设计派生类时，对继承过来的成员变量的初始化工作也要由派生类的构造函数完成，但是大部分基类都有private属性的成员变量，它们在派生类中无法访问，更不能使用派生类的构造函数来初始化。这种矛盾在C++继承中是普遍存在的，解决这个问题的思路是：在派生类的构造函数中调用基类的构造函数。

2、析构函数

析构函数不能被继承，释放对象的时候需要先调用派生类析构函数然后调用基类析构函数。

3、赋值运算符=

这里面说一下为什么赋值运算符不能被继承，其实不应该说不能被继承，而是被覆盖了。第一点是在c++的编译器中如果没有定义赋值运算符，会自动加上一个默认的。所以如果赋值运算符可以被继承，则会导致派生类也会有这个赋值运算符。第二就是在如果派生类的成员和基类的成员有相同的声明，那么派生类会覆盖基类的成员，哪怕参数和数据类型都不相同，也会被覆盖。显然，B1中的赋值运算符函数名operator =和基类A1中的operator =同名，所以，A1中的赋值运算符函数int perator=(int a);被B1中的隐含的赋值运算符函数B1& perator =(const B1& robj);所覆盖。所以赋值运算符会被覆盖，不能被继承，那么派生类就不能使用基类中的赋值运算符做一些事情，就像图上说的特征标随类而异。举个例子就是基类A中赋值运算符参数是int，但是派生类赋值运算符参数是类类型，导致编译出错。

1
class A1
2
{
3
public:
4
    int perator=(int a)
5
    {
6
        return 8;
7
    }
8
};
9

10

11
class B1 : public A1
12
{
13
public:
14
     B1& operator =(const B1& robj); // 注意这一行是编译器添加的，派生类和基类参数都不一样，肯定会报错。
15
};
16
B1 b;
17
int a= 8
18
b=a//报错。

展开收起

除了如上面的三个函数不能被继承外还有一些，如：

c++11的final关键字

将自身的构造函数与析构函数放在private作用域内

友元+虚继承

解释一下这个，首先要明白什么是友元和虚继承。

友元：友元的本质就是想在类外不通过成员函数访问类的私有成员，分为友元函数和友元类。友元函数内部可以直接访问私有成员。一个类A可以将另一个类B声明为自己的友元，类B的所有成员函数就都可以访问类 A 对象的私有成员。

虚继承：虚拟继承是多重继承中特有的概念。虚拟基类是为解决多重继承而出现的。如<类d继承自类b1>、B2，而类B1、B2都继承自类A，因此在类D中两次出现类A中的变量和函数。为了节省内存空间，可以将B1、B2对A的继承定义为虚拟继承，而A就成了虚拟基类。虚拟继承在一般的应用中很少用到，所以也往往被忽视，这也主要是因为在C++中，多重继承是不推荐的，也并不常用，而一旦离开了多重继承，虚拟继承就完全失去了存在的必要因为这样只会降低效率和占用更多的空间。

1
class CFinalClassMixin {//从这个类中继承的类都不能再被继承
2
  friend class Cparent;
3
private:
4
  CFinalClassMixin() {}
5
  ~CFinalClassMixin(){}
6
};
7
class Cparent: virtual public CFinalClassMixin, public CXXX {
8
public:
9
  Cparent() {}
10
  ~Cparent(){}
11
};
12
class CChild : public Cparent {
13
public:
14
  CChild() {};//编译错误
15
  ~CChild() {};//编译错误
16
};

展开收起

如果不是虚继承，那么CChild直接调用Cparent的构造函数，这是成立的，而且CChild是不需要调用CFinalClassMixin的构造函数。若把它声明为虚继承（派生类对象一定会调用基类的构造函数），那么CChild就必须负责CFinalClassMixin构造函数的调用，这样又因为不能继承friend类，所以不能调用，造成了错误。

成员初始化列表#

c++11新特性里面说的有，很详细

谈一谈new/delete和malloc/free的区别和联系（c++管理内存的方式）#

• 相同点

  都是用来申请动态内存和释放动态内存的

• 区别（主要是new和malloc的却别）

  • 概念上的区别

    malloc/free是C++/C语言的标准库函数，而new/delete是C++的运算符。因此malloc仅仅只分配内存，而不会进行初始化类成员的工作，new不止分配内存，而且还是调用类的构造函数。

  • 返回类型的安全性

    new操作符内存分配成功时候，返回的是对象类型的指针，不需要进行类型转换，从这个角度来说比较安全

    malloc内存分配成功则返回void*类型（泛型指针），必须通过强制类型转换将void* 转换成需要的类型。

  • 分配失败后返回值也不同

    malloc失败，会返回空指针。

    new失败，默认是抛出异常，要捕获异常bad_alloc

    1
    try
    2
    {
    3
        int *a = new int();
    4
    }
    5
    catch (bad_alloc)
    6
    {
    7
        ...
    8
    }

  • 是否需要指定内存大小

    new操作符申请内存的时候不需要指定内存块的大小，编译器会自动根据类型信息来计算

    malloc需要显示的指出内存的大小

  • new的内部

    调用new 操作符分配对象时会经历三个步骤：

    1. 调用operator new函数分配一块足够大的，原始的空间
    2. 编译器运行相应的构造函数以构造对象，并传入初值
    3. 构造完对象后，就返回一个指向该对象的指针。

  • 后续内存的分配

    当malloc分配内存后，发现后续内存分配不足的时候，可以使用realloc函数进行内存重载实现内存的扩充。realloc会先判断当前指针所指向的内存是否有足够的连续空间，如果有则可以原地扩大内存地址，并返回原来地址空间指针。如果空间不够，就从新分配一个空间，将原来的数据拷贝到新分配的内存区域，释放原来的内存区域。

    new没有这样的配套设施

有了malloc/free为什么还要new/delete？#

对于一些非内部数据类型(eg<类对象>)来说，光用maloc/free无法满足要求。对象在创建的同时要自动执行构造函数，对象在消亡的时候要自动执行析构函数，而由于malloc/free是库函数而不是运算符，不在编译器的控制权限内（库函数是编译好的代码由链接器链接到为我们的代码中），也就不能自动执行构造函数和析构函数。所以，在c++中需要一个能完成动态内存分配和初始化工作的运算符new，以及一个能完成清理和释放内存工作的运算符delete。

比如有一个类，你用malloc后，可以看到该对象的成员变量并没有被初始化，因此自定义类型的用malloc不合适。

既然new/delete 的功能完全覆盖了malloc/free，为什么C++不把malloc/free 淘 汰出局呢？这是因为C++程序经常要调用C 函数，而C 程序只能用malloc/free 管理动 态内存。 如果用free 释放“new 创建的动态对象”，那么该对象因无法执行析构函数而可能 导致程序出错。如果用delete 释放“malloc 申请的动态内存”，理论上讲程序不会出错， 但是该程序的可读性很差。所以new/delete 必须配对使用，malloc/free 也一样。

new delete，new[] delete[]一定要配对使用吗？为什么？#

首先可以明确一点：配套使用是肯定没有错的。

• new和delete

  new和delete主要是为了为那些自定义类型的对象开辟空间，因为这些对象在创建的时候要自动执行构造函数，消亡的时候要执行析构函数，对于自定义类型对象如果不配对使用的话，可能会出现没有析构干净的情况

• new[]和delete[]

  我们再用new[]创建数组的时候，比如一个对象大小为N，则K个数组需要K*N个空间来构造。那当delete的时候如何知道这个数组空间的大小呢？我们会在new出来的这个空间的头部申请一个int类型的字节，4字节用来存储数组的长度，这样调用delete[]的时候就知道数组的大小，才会调用K次析构函数，释放K * N + 4字节大小的内存。

  下面针对自定义类型变量：

  如果new和delete[]使用，delete的时候会找前4个字节，看要释放的内存有多大。但是使用new导致没有设备区部分4个字节用来存放数组长度，这样会导致这4个字节是未定义的，因此会调用不定次的delete。同时比如说其实地址为A，应该从A开始释放，现在会从A-4开始释放。

  如果new[]和delete一起使用，程序会认为这是一个对象占用的空间，而不是数组，因此就析构一次。同时释放的是new[]中表示长度的前4个字节的地址，应该从A-4开始释放，如果不从头释放的话回出问题。

free释放内存的理解#

其实malloc算法有很多，除了glibc使用的ptmalloc以外，还有tcmalloc, jemalloc等等。但总体上个人认为主要分两个流派。第一个流派是ptmalloc为代表的隐藏头风格，第二个流派就是以tcmalloc和jemalloc为代表的位图风格。且就目前的情况看，后者在性能上要占据上风。其中一个重要原因在于，隐藏头风格的算法，元数据（即chunk size）之间间隔太远，不利于CPU cache命中。

• 如何知道要释放的空间大小？

  对于glibc的malloc算法，空间的大小记录在参数指针指向地址的前面，free的时候通过这个记录即可知道要释放的内存有多大。

你把房子卖了，你就算还拿着钥匙，能进门，这也不是你的房子了。你照样可以把你的钱放在在这个房子里，但是不保证过一会还在。

p，你的房子所在地址，根据p这个地址，你可以找到你的房子，在有效范围内生活（如做饭、大便等），但记得别越界到邻居家了；如memcpy(p, xxx, xx);需要指定长度

free(p)后你把房子卖了，但p这个地址还存在你的记忆中，除非你把你房子的地址从你记忆中抹去，即p = NULL;

如果你没有抹去对你房子的记忆，即p != NULL; 你仍然可以找到那所房子，但是那房子已经不属于你了；

如果你还要进房子生活（如做饭、大便等），即对p进行写入操作，那么你已经违法了

参考链接

被free回收的内存是立即返还给操作系统吗？

这个需要看源码。

被free回收的内存会首先被ptmalloc使用双链表保存起来，当用户下一次申请内存的时候，会尝试从这些内存中寻找合适的返回。这样就避免了频繁的系统调用，占用过多的系统资源。同时ptmalloc也会尝试对小块内存进行合并，避免过多的内存碎片

怎么在栈上分配内存？#

alloca函数

alloca函数分配的内存不需要手动释放，和普通的栈上对象的处理一样：超出作用域自动回收内存。

alloca函数并不被推荐使用，因为它不安全。对于一个很大的数据结构，如果采用默认的内存分配模式，会引起爆栈。但是你用alloca去分配，虽然能够在栈上得到一个地址，但是这个地址可能超出了栈的边界，可能对其他的内存空间造成了破坏。并且alloca函数本身不知道是否踩了其他的内存空间。

使用场景：有时候我们只是想暂时打印日志信息或者错误信息，并不需要长期保存其内容，随着程序运行超出数组作用域，内存自动释放。下次需要的时候再动态的申请，不用管理释放，这样很方便

1
if(!result){
2
  int length;
3
  length = getLogLength();      //凭空捏造的函数
4
  char* message = (char*)alloca(sizeof(char) * length);
5
  message = getLogInformation();  //凭空捏造的函数
6
  std:cout << message << std::endl;
7
}

带返回值的函数如果不return会怎么样？#

首先不是BUG，这种情况属于未定义的行为，而未定义的行为不会导致编程失败。

当main函数没有return结尾的时候会在生成的目标文件中自动加入return 0

c++ 四种强制类型转换#

参考链接

向上类型转换和向下类型转换#

说这个之前要说一下类对象的内存结构：

**向上类型转换：**upcast，把派生类的指针或引用转换成基类的指针或者引用是安全的（或者说基类指针指向派生类）；因为用转换后的指针只能访问基类部分的函数时候，都可以访问，肯定安全。这个是隐式转换，c++认为是安全的。

**向下类型转换：**downcast，把基类指针或引用转换成派生类表示（或者说把派生类指针指向基类）时，由于没有动态类型检查，所以是不安全的。如果转换后的指针访问派生类新增加的函数，这个时候基类中本来没有这个函数，那就会出错。

很形象，向上就是派生类指针变成基类指针，向下就是基类指针变成派生类指针。

RAII基本理解与使用#

**基本概念：**RAII是c++中的一个惯用法，即“Resource Acquisition Is Initialization”，翻译为“资源获取就初始化”。是一种资源管理技术。c++之父说这种技术是依赖于类中构造函数和析构函数的性质以及与异常处理的交互性质来管理资源。

**提出原因：**首先要明确在计算机系统中，资源的数量是有限的，一定要合理管理和使用有限的资源。比如内存，文件，套接字等等吧。因此在使用资源的时候要遵循三个步骤：

1. 获取资源
2. 使用资源
3. 释放资源

正常情况下没什么问题，大家都非常规规矩矩的这样做。但是我们都知道程序员很懒，一般不喜欢干重复性很高的工作，因此有两种情况下会出现一些问题。第一种比如说对文件操作，考虑一种极端情况，各种if判断后都要释放资源，也就是说释放资源的语句要写很多次，这样是非常麻烦的。第二种情况就是在使用资源的过程中程序会抛出异常，我们必须用catch来捕获所有异常然后关闭文件，当控制流程特别复杂的时候就很烦，代码很臃肿。而且有时候释放资源的语句就不会被执行。那么有些资源就是放不掉，因此Bjarne Stroustrup就想到不管啥情况都能释放资源的就是析构函数，因为stack unwinding（栈展开）导致析构函数能被执行。因此将资源的初始化和释放都放到一个类中就能解决上面遇到的问题。

stack winding program run, each function(data, registers, program counter, etc) is mapped onto the stack as it is called. Because the function calls other functions, they too are mapped onto the stack. This is stack winding.

stack unwinding is the removal of the functions from the stack in the reverse order.(展开是以相反的顺序从堆栈中删除函数)。在c++中，系统必须确保调用所有创建起来的局部对象的析构函数。

**总结：**在构造函数中申请分配资源，在析构函数中释放资源。因为C++的语言机制保证了，当一个对象创建的时候，自动调用构造函数，当对象超出作用域的时候会自动调用析构函数。所以，在RAII的指导下，我们应该使用类来管理资源，将资源和对象的生命周期绑定。RAII的核心思想是将资源或者状态与对象的生命周期绑定，通过C++的语言机制，实现资源和状态的安全管理,智能指针是RAII最好的例子。

RALL是c++区别于其他所有编程语言的重要特性。最初学习c++时的教条是new和delete一定要配套使用，但是使用RALL思想后，改成每一个资源配置动作都应该在单一语句执行，获得资源后立刻交给对象去管理，一般不要出现delete，用智能指针。

C++11的enum class 、enum struct 和 enum#

枚举类型(enumeration)使我们可以将一组整型常量组织在一起。每个枚举类型定义了一种新的类型。枚举属于字面值常量类型。

• 旧版本enum存在的问题

  1. 没有非常完全的类型安全。即不同枚举之间不能赋值，同时整形不能向枚举类型转换，但是枚举可以向整形转。
  2. 无法确定数据的类型，导致无法明确枚举类型所占用的内存大小。
  3. 枚举中的成员可以在括号外部直接访问，而不需要使用域运算符。

• enum class 、enum struct

  有更好的类型安全和封装的特性。

  1. 与整形之间不会发生隐式类型转换，除非用static_cast强制转换
  2. 可以指定底层的数据类型，默认是int
  3. 需要通过域运算符来访问枚举成员

内存泄漏？出现内存泄漏如何调试？#

内存泄露一般指的是堆内存的泄露，即用户自己开辟的内存空间。应用程序使用malloc、realloc、new等函数从堆中分配到一块内存后，必须调用free或delete进行回收，否则这块内存不能继续被使用。内存泄漏会因为减少可用内存的数量从而降低计算机的性能。最终，在最糟糕的情况下，过多的可用内存被分配掉导致全部或部分设备停止正常工作，或者应用程序崩溃。内存泄漏可能不严重，甚至能够被常规的手段检测出来。在现代操作系统中，一个应用程序使用的常规内存在程序终止时被释放。这表示一个短暂运行的应用程序中的内存泄漏不会导致严重后果。在C++中出现内存泄露的主要原因就是程序猿在申请了内存后(malloc(), new)，没有及时释放没用的内存空间，甚至消灭了指针导致该区域内存空间根本无法释放。

内存泄漏的原因

1. malloc/new和delete/free没有匹配
2. new[] 和 delete[]也没有匹配
3. 没有将父类的析构函数定义为虚函数，当父类的指针指向子类对象时，delete该对象不会调用子类的析构函数

检测手段

1. 良好的程序设计能力，把new和delete全部都封装到构造函数和析构函数中，保证任何资源的释放都在析构函数中进行
2. 智能指针（万一被问道，这也是一个问题）
3. valgrind ，这个可以打印出发生内存泄露的部分代码
4. linux使用swap命令观察还有多少可以用的交换空间，两分钟内执行三四次，肉眼看看交换区是不是变小了
5. 使用/usr/bin/stat工具如netstat、vmstat等。如果发现波段有内存被分配且没有释放，有可能进程出现了内存泄漏。

valgrind

参考

:watermelon++11新特性#

参考链接

1
 //潜在的资源泄露
2
processWidget(std::shared_ptr<Widget>(new Widget),computePriority());

1
执行“new Widget”。
2
执行computePriority。
3
执行std::shared_ptr的构造函数。

1
struct A{
2
    shared_ptr<B> b;
3
};
4
struct B{
5
    shared_ptr<A> a;
6
};
7
shared_ptr<A> pa = make_shared<A>();
8
shared_ptr<B> pb = make_shared<B>();
9
pa->b = pb;
10
pb->a = pa;

1
struct A{
2
    shared_ptr<B> b;
3
};
4
struct B{
5
    weak_ptr<A> a;
6
};
7
shared_ptr<A> pa = make_shared<A>();
8
shared_ptr<B> pb = make_shared<B>();
9
pa->b = pb;
10
pb->a = pa;

1
std::unique_ptr<A> a1(new A());
2
std::unique_ptr<A> a2 = a1;//编译报错，不允许复制
3
std::unique_ptr<A> a3 = std::move(a1);//可以转移所有权，所有权转义后a1不再拥有任何指针

1
std::unique_ptr<A> a1(new A());
2
A *origin_a = a1.get();//尽量不要暴露原生指针
3
std::unique_ptr<A> a2(a1.release());//常见用法，转义拥有权
4
a2.reset(new A());//释放并销毁原有对象，持有一个新对象
5
a2.reset();//释放并销毁原有对象，等同于下面的写法
6
a2 = nullptr;//释放并销毁原有对象

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

1
void f(void*){}
2

3
void f(int){}
4

5
int main()
6
{
7
    f(NULL); // what function will be called?
8
}

1
class classA {...};
2
class classB
3
{
4
public:
5
    //赋值
6
    classB(classA a) {mA = a;}
7
    //成员列表初始化
8
    classB(classA a): mA(a) {}
9
private:
10
    classA mA;
11
};