想了解详解C++编程中运算符的使用的相关内容吗，在本文为您仔细讲解C++的运算符的相关知识和一些Code实例，欢迎阅读和指正，我们先划重点：C++,运算符，下面大家一起来学习吧。

在本章中主要介绍算术运算符与算术表达式，赋值运算符与赋值表达式，逗号运算符与逗号表达式，其他运算符将在以后各章中陆续介绍。

需要说明，两个整数相除的结果为整数，如5/3的结果值为1，舍去小数部分。但是，如果除数或被除数中有一个为负值，则舍入的方向是不固定的。例如，-5/3在有的C++系统上得到结果-1，有的C++系统则给出结果-2。多数编译系统采取“向零取整”的方法，即5/3的值等于1，-5/3的值等于-1，取整后向零靠拢。

如果参加+,  -,  *, / 运算的两个数中有一个数为float型数据，则运算的结果是double型，因为C++在运算时对所有float型数据都按double型数据处理。
算术表达式和运算符的优先级与结合性

用算术运算符和括号将运算对象（也称操作数）连接起来的、符合C++语法规则的式子，称C++算术表达式。运算对象包括常量、变量、函数等。例如，下面是一个合法的C++算术表达式：

C++语言规定了运算符的优先级和结合性。在求解表达式时，先按运算符的优先级别高低次序执行，例如先乘除后加减。如有表达式a-b*c，b的左侧为减号，右侧为乘号，而乘号优先于减号，因此，相当于a-（b*c）。如果在一个运算对象两侧的运算符的优先级别相同，如a-b+c，则按规定的“结合方向”处理。

C++规定了各种运算符的结合方向（结合性），算术运算符的结合方向为“自左至右”，即先左后右，因此b先与减号结合，执行a-b的运算，再执行加c的运算。“自左至右的结合方向”又称“左结合性”，即运算对象先与左面的运算符结合。以后可以看到有些运算符的结合方向为“自右至左”，即右结合性（例如赋值运算符）。关于“结合性”的概念在其他一些高级语言中是没有的，是C和C++的特点之一，希望能弄清楚。

表达式中各类数值型数据间的混合运算

在表达式中常遇到不同类型数据之间进行运算，如：

在进行运算时，不同类型的数据要先转换成同一类型，然后进行运算。转换的规则按图所示。

假设已指定i为整型变量，f为float变量，d为double型变量，e为long型，有下面表达式：

进行10+'a'的运算，先将'a'转换成整数97，运算结果为107。
进行i*f的运算。先将i与f都转换成double型，运算结果为double型。
整数107与i*f的积相加。先将整数107转换成双精度数（小数点后加若干个0，即107.000…00），结果为double型。

上述的类型转换是由系统自动进行的。

C++自增和自减运算符(--和++) 在C和C++中，常在表达式中使用自增（++）和自减（--）运算符，他们的作用是使变量的值增1或减1，如：
++i（在使用i之前，先使i的值加1，如果i的原值为3，则执行j=++i后，j的值为4）
--i （在使用i之前，先使i的值减1，如果i的原值为3，则执行j=--i后，j的值为2）
i++ （在使用i之后，使i的值加1，如果i的原值为3，则执行j=i++后，j的值为3，然后i变为4）
i--（在使用i之后，使i的值减1，如果i的原值为3，则执行j=i--后，j的值为3，然后i变为2）
++i是先执行i=i+1后，再使用i的值;而i++是先使用i的值后，再执行i=i+1。

正确地使用++和--，可以使程序简洁?清晰?高效。请注意：
自增运算符（++）和自减运算符（--）只能用于变量，而不能用于常量或表达式。
++和--的结合方向是“自右至左”。
自增运算符（++）和自减运算符（--）使用十分灵活，但在很多情况下可能出现歧义性，产生“意想不到”的副作用。
自增（减）运算符在C++程序中是经常见到的，常用于循环语句中，使循环变量自动加1。也用于指针变量，使指针指向下一个地址。

C语言面试题大汇总之华为面试题

1、局部变量能否和全局变量重名？

答：能，局部会屏蔽全局。要用全局变量，需要使用"::" ;局部变量可以与全局变量同名，在函数内引用这个变量时，会用到同名的局部变量，而不会用到全局变量。对于有些编译器而言，在同一个函数内可以定义多个同名的局部变量，比如在两个循环体内都定义一个同名的局部变量，而那个局部变量的作用域就在那个循环体内。

2、如何引用一个已经定义过的全局变量？

答：extern可以用引用头文件的方式，也可以用extern关键字，如果用引用头文件方式来引用某个在头文件中声明的全局变理，假定你将那个编写错了，那么在编译期间会报错，如果你用extern方式引用时，假定你犯了同样的错误，那么在编译期间不会报错，而在连接期间报错。

3、全局变量可不可以定义在可被多个.C文件包含的头文件中？为什么？

答：可以，在不同的C文件中以static形式来声明同名全局变量。可以在不同的C文件中声明同名的全局变量，前提是其中只能有一个C文件中对此变量赋初值，此时连接不会出错.

4、请写出下列代码的输出内容

5、static全局变量与普通的全局变量有什么区别？static局部变量和普通局部变量有什么区别？static函数与普通函数有什么区别？

答: 1) 全局变量(外部变量)的说明之前再冠以static 就构成了静态的全局变量。全局变量本身就是静态存储方式，静态全局变量当然也是静态存储方式。这两者在存储方式上并无不同。这两者的区别在于非静态全局变量的作用域是整个源程序，当一个源程序由多个源文件组成时，非静态的全局变量在各个源文件中都是有效的。而静态全局变量则限制了其作用域，即只在定义该变量的源文件内有效，在同一源程序的其它源文件中不能使用它。由于静态全局变量的作用域局限于一个源文件内，只能为该源文件内的函数公用，因此可以避免在其它源文件中引起错误。

2) 从以上分析可以看出，把局部变量改变为静态变量后是改变了它的存储方式即改变了它的生存期。把全局变量改变为静态变量后是改变了它的作用域，限制了它的使用范围。 3) static函数与普通函数作用域不同,仅在本文件。只在当前源文件中使用的函数应该说明为内部函数(static)，内部函数应该在当前源文件中说明和定义。对于可在

在使用STL容器（比如map、list、vector等）的时候，是用放一个对象还是放一个对象指针，即是用vector<int>还是vector<int*>，这里的vector可以换成其他的容器，int可以换成其他基本类型，也可以自定义的数据结构或类。首先，要说明的是，这两种方式，怎么用都可以实现功能，把一组整型数放到容器里。先看看两种方式在使用的时候的区别.

这种方式不需要动态new内存，当然也不用delete。

这种方式采用new，当然也要用delete:

2）当int改变成其他类型或结构或类的时候，用vector<int*>这种方式比较方便，容器里放的内容占用的内存也相对要少一些，指针在用的时候，去申请空间，不用，那就是个占用4个字节的地址。

如果要将一个临时变量push到容器的末尾，push_back()需要先构造临时对象，再将这个对象拷贝到容器的末尾，而emplace_back()则直接在容器的末尾构造对象，这样就省去了拷贝的过程。

C++ 11的语法 for(int a:b) 从数组b依次取出元素赋值给整型变量a，循环执行for中语句

map内部实现了一个红黑树，该结构具有自动排序的功能，因此map内部的所有元素都是有序的，红黑树的每一个节点都代表着map的一个元素，因此，对于map进行的查找，删除，添加等一系列的操作都相当于是对红黑树进行这样的操作，故红黑树的效率决定了map的效率。

unordered_map: unordered_map内部实现了一个哈希表，因此其元素的排列顺序是杂乱的，无序的

有序性，这是map结构最大的优点，其元素的有序性在很多应用中都会简化很多的操作

红黑树，内部实现一个红黑书使得map的很多操作在lgn的时间复杂度下就可以实现，因此效率非常的高

空间占用率高，比起unordered_map还是低一点。因为map内部实现了红黑树，虽然提高了运行效率，但是因为每一个节点都需要额外保存父节点，孩子节点以及红/黑性质，使得每一个节点都占用大量的空间适用处，对于那些有顺序要求的问题，用map会更高效一些

因为内部实现了哈希表，因此其查找速度非常的快

哈希表的建立比较耗费时间

适用处，对于查找问题，unordered_map会更加高效一些，因此遇到查找问题，常会考虑一下用unordered_map

对于unordered_map或者unordered_set容器，其遍历顺序与创建该容器时输入元素的顺序是不一定一致的，遍历是按照哈希表从前往后依次遍历的

set、map的使用及其特性和区别

STL总共实现了两种不同结构的管理式容器：树型结构与哈希结构。树型结构的关联式容器主要有四种：set，map，multiset，multimap。

set里面每个元素只存有一个key值，它支持高效的关键字查询操作，比如检查一个关键字是否在set中。如果这个key值之前存在的话就不插入。

插入如上数据之后，打印出来的值为1 2 3 4 5。set容器自动对以上数据进行了排序，并且实现了去重。但是不能对set里的值进行修改。

set容器中的find查找效率高，因为底层是一个二叉搜索树，比要查找的值小就去左子树查找，反之则去右子树查找。

s.erase(pos);//找到了我就删，没找到要删的话会报错
 

采用s.erase(3);这种操作如果没有3并不会报错，如果有3则会删除这个结点。找到pos位置，采用s.erase(pos);这种操作如果没有3则会报错，如果有3则会删除这个结点。

两个set的交换的其实是交换结点的指针，效率高。

其实整体的接口和set都相同，但是multiset可以插入key相同的值。 multiset和set一样不能够对数据进行修改。

有别于set的是，map是一种key(键),value(值)的形式，用来保存键和值组成的集合，键必须是唯一的，但值可以不唯一。里面的元素可以根据键进行自动排序，由于map是key_value的形式，所以map里的所有元素都是pair类型。pair里面的first被称为key(键），second被称为value(值）。 它可以通过关键字查找映射关联信息value，同时根据key值进行排序。

multimap允许key值的冗余，因此key值相同也可以进行插入。

set是一种关联式容器，其特性如下：

4所有的元素都会被自动排序

5不能通过迭代器来改变set的值，因为set的值就是键

map和set一样是关联式容器，它们的底层容器都是红黑树，区别就在于map的值不作为键，键和值是分开的。它的特性如下：

2所有元素都是键+值存在

4所有元素是通过键进行自动排序的

5map的键是不能修改的，但是其键对应的值是可以修改的

C++动态内存分配方式

若是分配失败则可以跑异常

注意，析构函数和构造函数都没有返回值。

下面的代码中成员函数返回引用要比返回值快很多，因为不需要复制这个操作。

friend语句总是紧跟在类标题语句之后，比如

引用的本质 （在c++内部实现是一个指针常量.） 引用就是指针常量：指向的地址不变，地址里的内容可以改变。

• 指针是一个变量，存储的是一个地址，引用跟原来的变量实质上是同一个东西，是原变量的别名
• 指针可以有多级，引用只有一级
• 指针可以为空，引用不能为NULL且在定义时必须初始化
• 指针在初始化后可以改变指向，而引用在初始化之后不可再改变
• sizeof指针得到的是本指针的大小，sizeof引用得到的是引用所指向变量的大小
• 当把指针作为参数进行传递时，也是将实参的一个拷贝传递给形参，两者指向的地址相同，但不是同一个变量，在函数中改变这个变量的指向不影响实参，而引用却可以。
• 引用只是别名，不占用具体存储空间，只有声明没有定义；指针是具体变量，需要占用存储空间。
• 引用在声明时必须初始化为另一变量，一旦出现必须为typename refname &varname形式；指针声明和定义可以分开，可以先只声明指针变量而不初始化，等用到时再指向具体变量。
• 引用一旦初始化之后就不可以再改变（变量可以被引用为多次，但引用只能作为一个变量引用）；指针变量可以重新指向别的变量。
• 不存在指向空值的引用，必须有具体实体；但是存在指向空值的指针。

• 申请方式不同：栈由系统自动分配；堆是自己申请和释放的。
• 申请大小限制不同：栈顶和栈底是之前预设好的，栈是向栈底扩展，大小固定，可以通过ulimit -a查看，由ulimit -s修改；堆向高地址扩展，是不连续的内存区域，大小可以灵活调整。
• 申请效率不同：栈由系统分配，速度快，不会有碎片；堆由程序员分配，速度慢，且会有碎片。

• nt *p[10]表示指针数组，强调数组概念，是一个数组变量，数组大小为10，数组内每个元素都是指向int类型的指针变量。
• int (*p)[10]表示数组指针，强调是指针，只有一个变量，是指针类型，不过指向的是一个int类型的数组，这个数组大小是10。
• int *p(int)是函数声明，函数名是p，参数是int类型的，返回值是int *类型的。
• int (*p)(int)是函数指针，强调是指针，该指针指向的函数具有int类型参数，并且返回值是int类型的。

基类的虚函数表存放在内存的什么区，虚表指针vptr的初始化时间

首先整理一下虚函数表的特征：

• 虚函数表是全局共享的元素，即全局仅有一个，在编译时就构造完成
• 虚函数表类似一个数组，类对象中存储vptr指针，指向虚函数表，即虚函数表不是函数，不是程序代码，不可能存储在代码段
• 虚函数表存储虚函数的地址,即虚函数表的元素是指向类成员函数的指针,而类中虚函数的个数在编译时期可以确定，即虚函数表的大小可以确定,即大小是在编译时期确定的，不必动态分配内存空间存储虚函数表，所以不在堆中
  根据以上特征，虚函数表类似于类中静态成员变量.静态成员变量也是全局共享，大小确定，因此最有可能存在全局数据区，测试结果显示：

虚函数表vtable在Linux/Unix中存放在可执行文件的只读数据段中(rodata)，这与微软的编译器将虚函数表存放在常量段存在一些差别

由于虚表指针vptr跟虚函数密不可分，对于有虚函数或者继承于拥有虚函数的基类，对该类进行实例化时，在构造函数执行时会对虚表指针进行初始化，并且存在对象内存布局的最前面。
《虚函数表存放在哪里》：
一般分为五个区域：栈区、堆区、函数区（存放函数体等二进制代码）、全局静态区、常量区 C++中虚函数表位于只读数据段（.rodata），也就是C++内存模型中的常量区；而虚函数则位于代码段（.text），也就是C++内存模型中的代码区。

• 声明仅仅是把变量的声明的位置及类型提供给编译器，并不分配内存空间；定义要在定义的地方为其分配存储空间。
• 相同变量可以在多处声明（外部变量extern），但只能在一处定义。

哪几种情况必须用到初始化成员列表？

• 初始化一个const成员。
• 调用一个基类的构造函数，而该函数有一组参数。
• 调用一个数据成员对象的构造函数，而该函数有一组参数。

• sizeof是运算符，并不是函数，结果在编译时得到而非运行中获得；strlen是字符处理的库函数。
• sizeof参数可以是任何数据的类型或者数据（sizeof参数不退化）；strlen的参数只能是字符指针且结尾是'\0'的字符串。
• 因为sizeof值在编译时确定，所以不能用来得到动态分配（运行时分配）存储空间的大小。

• a是数组名，是数组首元素地址，+1表示地址值加上一个int类型的大小，如果a的值是0x，加1操作后变为0x。(a + 1) = a[1]。
• &a是数组的指针，其类型为int (*)[10]（就是前面提到的数组指针），其加1时，系统会认为是数组首地址加上整个数组的偏移（10个int型变量），值为数组a尾元素后一个元素的地址。
• 若(int *)p ，此时输出 *p时，其值为a[0]的值，因为被转为int *类型，解引用时按照int类型大小来读取。

数组名和指针（这里为指向数组首元素的指针）区别？

• 二者均可通过增减偏移量来访问数组中的元素。
• 数组名不是真正意义上的指针，可以理解为常指针，所以数组名没有自增、自减等操作。
• 当数组名当做形参传递给调用函数后，就失去了原有特性，退化成一般指针，多了自增、自减操作，但sizeof运算符不能再得到原数组的大小了。

• 都是是指向无效内存区域(这里的无效指的是"不安全不可控")的指针，访问行为将会导致未定义行为。
• 避免野指针比较简单，但悬空指针比较麻烦。c++引入了智能指针，C++智能指针的本质就是避免悬空指针的产生。
• 野指针：指针变量未及时初始化 => 定义指针变量及时初始化，要么置空。
• 悬空指针：指针free或delete之后没有及时置空 => 释放操作后立即置空。

• 1、尾后插入：size < capacity时，首迭代器不失效尾迭代失效（未重新分配空间），size == capacity时，所有迭代器均失效（需要重新分配空间）。
• 2、中间插入：中间插入：size < capacity时，首迭代器不失效但插入元素之后所有迭代器失效，size == capacity时，所有迭代器均失效。
• 尾后删除：只有尾迭代失效。
• 中间删除：删除位置之后所有迭代失效。

• 标准C++中的字符串类取代了标准C函数库头文件中的字符数组处理函数（C中没有字符串类型）。
• C++中用来做控制态输入输出的iostream类库替代了标准C中的stdio函数库。
• 在C++中，允许有相同的函数名，不过它们的参数类型不能完全相同，这样这些函数就可以相互区别开来。而这在C语言中是不允许的。也就是C++可以重载，C语言不允许。
• C++语言中，允许变量定义语句在程序中的任何地方，只要在是使用它之前就可以；而C语言中，必须要在函数开头部分。而且C++允许重复定义变量，C语言也是做不到这一点的
• 在C++中，除了值和指针之外，新增了引用。引用型变量是其他变量的一个别名，我们可以认为他们只是名字不相同，其他都是相同的。
• 《C语言与C++有什么区别？》

• Java语言给开发人员提供了更为简洁的语法；完全面向对象，由于JVM可以安装到任何的操作系统上，所以说它的可移植性强
• Java语言中没有指针的概念，引入了真正的数组。不同于C++中利用指针实现的“伪数组”，Java引入了真正的数组，同时将容易造成麻烦的指针从语言中去掉，这将有利于防止在C++程序中常见的因为数组操作越界等指针操作而对系统数据进行非法读写带来的不安全问题
• C++也可以在其他系统运行，但是需要不同的编码（这一点不如Java，只编写一次代码，到处运行），例如对一个数字，在windows下是大端存储，在unix中则为小端存储。Java程序一般都是生成字节码，在JVM里面运行得到结果
• Java用接口(Interface)技术取代C++程序中的多继承性。接口与多继承有同样的功能，但是省却了多继承在实现和维护上的复杂性
• C++用析构函数回收垃圾，写C和C++程序时一定要注意内存的申请和释放
• Java语言不使用指针，内存的分配和回收都是自动进行的，程序员无须考虑内存碎片的问题
• Java在桌面程序上不如C++实用，C++可以直接编译成exe文件，指针是c++的优势，可以直接对内存的操作，但同时具有危险性 。（操作内存的确是一项非常危险的事情，一旦指针指向的位置发生错误，或者误删除了内存中某个地址单元存放的重要数据，后果是可想而知的）
• Java在Web 应用上具有C++ 无可比拟的优势，具有丰富多样的框架
• 对于底层程序的编程以及控制方面的编程，C++很灵活，因为有句柄的存在
• 《C++和java的区别和联系》：

• 两者都拥有成员函数、公有和私有部分
• 任何可以使用class完成的工作，同样可以使用struct完成
• 两者中如果不对成员不指定公私有，struct默认是公有的，class则默认是私有的
• C语言中：struct是用户自定义数据类型（UDT）；C++中struct是抽象数据类型（ADT），支持成员函数的定义，（C++中的struct能继承，能实现多态）
• C中struct是没有权限的设置的，且struct中只能是一些变量的集合体，可以封装数据却不可以隐藏数据，而且成员不可以是函数
• C++中，struct增加了访问权限，且可以和类一样有成员函数，成员默认访问说明符为public（为了与C兼容）
• struct作为类的一种特例是用来自定义数据结构的。一个结构标记声明后，在C中必须在结构标记前加上struct，才能做结构类型名（除：typedef struct class{};）;C++中结构体标记（结构体名）可以直接作为结构体类型名使用，此外结构体struct在C++中被当作类的一种特例
• 《struct结构在C和C++中的区别》：

• define是在编译的预处理阶段起作用，而const是在编译、运行的时候起作用
• define只做替换，不做类型检查和计算，也不求解，容易产生错误，**一般最好加上一个大括号包含住全部的内容，要不然很容易出错 **
• const常量有数据类型，编译器可以对其进行类型安全检查
• define只是将宏名称进行替换，在内存中会产生多分相同的备份。const在程序运行中只有一份备份，且可以执行常量折叠，能将复杂的的表达式计算出结果放入常量表
• 宏替换发生在编译阶段之前，属于文本插入替换；const作用发生于编译过程中。
• 宏不检查类型；const会检查数据类型。
• **宏定义的数据没有分配内存空间，只是插入替换掉；const定义的变量只是值不能改变，但要分配内存空间。 **

• 隐藏。所有不加static的全局变量和函数具有全局可见性，可以在其他文件中使用，加了之后只能在该文件所在的编译模块中使用
• 默认初始化为0，包括未初始化的全局静态变量与局部静态变量，都存在全局未初始化区
• **静态变量在函数内定义，始终存在，且只进行一次初始化，具有记忆性，其作用范围与局部变量相同，函数退出后仍然存在，但不能使用 **
• static成员变量：只与类关联，不与类的对象关联。定义时要分配空间，**不能在类声明中初始化，必须在类定义体外部初始化，初始化时不需要标示为static；可以被非static成员函数任意访问。 **
• static成员函数：不具有this指针，无法访问类对象的非static成员变量和非static成员函数；不能被声明为const、虚函数和volatile；可以被非static成员函数任意访问
• **不考虑类的情况 **
• const常量在定义时必须初始化，之后无法更改
• const形参可以接收const和非const类型的实参，例如

• const成员变量：不能在类定义外部初始化，只能通过构造函数初始化列表进行初始化，并且必须有构造函数；不同类对其const数据成员的值可以不同，所以不能在类中声明时初始化
• const成员函数：const对象不可以调用非const成员函数；非const对象都可以调用；不可以改变非mutable（用该关键字声明的变量可以在const成员函数中被修改）数据的值

• 顶层const：指的是const修饰的变量本身是一个常量，无法修改，指的是指针，就是 * 号的右边
• 底层const：指的是const修饰的变量所指向的对象是一个常量，指的是所指变量，就是 * 号的左边

• 执行对象拷贝时有限制，常量的底层const不能赋值给非常量的底层const
• 使用命名的强制类型转换函数const_cast时，只能改变运算对象的底层const

类的对象存储空间？ (问号代表这个可能暂时不能理解，以下皆如此)

• 非静态成员的数据类型大小之和。
• 编译器加入的额外成员变量（如指向虚函数表的指针）。
• 为了边缘对齐优化加入的padding。

• 当在父类中使用了虚函数时候，你可能需要在某个子类中对这个虚函数进行重写，以下方法都可以：

• 如果不使用override，当你手一抖，将foo()写成了f00()会怎么样呢？结果是编译器并不会报错，因为它并不知道你的目的是重写虚函数，而是把它当成了新的函数。如果这个虚函数很重要的话，那就会对整个程序不利。所以，override的作用就出来了，它指定了子类的这个虚函数是重写的父类的，如果你名字不小心打错了的话，编译器是不会编译通过的：

• 当不希望某个类被继承，或不希望某个虚函数被重写，可以在类名和虚函数后添加final关键字，添加final关键字后被继承或重写，编译器会报错。例子如下：

拷贝初始化和直接初始化

• 当用于类类型对象时，初始化的拷贝形式和直接形式有所不同：直接初始化直接调用与实参匹配的构造函数，拷贝初始化总是调用拷贝构造函数。拷贝初始化首先使用指定构造函数创建一个临时对象，然后用拷贝构造函数将那个临时对象拷贝到正在创建的对象。举例如下

• 为了提高效率，允许编译器跳过创建临时对象这一步，直接调用构造函数构造要创建的对象，这样就完全等价于直接初始化了（语句1和语句3等价）。但是需要辨别两种情况。
• 当拷贝构造函数为private时：语句3和语句4在编译时会报错
• 使用explicit修饰构造函数时：如果构造函数存在隐式转换，编译时会报错
• C++的直接初始化与复制初始化的区别：

• 对于简单类型来说，初始化和赋值没什么区别
• 对于类和复杂数据类型来说，这两者的区别就大了，举例如下：

• 为了能够正确的在C++代码中调用C语言的代码：在程序中加上extern "C"后，相当于告诉编译器这部分代码是C语言写的，因此要按照C语言进行编译，而不是C++；
• （1）C++代码中调用C语言代码；
• （2）在C++中的头文件中使用；
• （3）在多个人协同开发时，可能有人擅长C语言，而有人擅长C++；
• 举个例子，C++中调用C代码：

• 参考的blog中有一篇google code上的文章，专门写extern "C"的，有兴趣的读者不妨去看看
• 综上，总结出使用方法，在C语言的头文件中，对其外部函数只能指定为extern类型，C语言中不支持extern "C"声明，在.c文件中包含了extern "C"时会出现编译语法错误。所以使用extern "C"全部都放在于cpp程序相关文件或其头文件中。
• （1）C++调用C函数：

• （2）C调用C++函数

模板函数和模板类的特例化 ??

• 编写单一的模板，它能适应多种类型的需求，使每种类型都具有相同的功能，但对于某种特定类型，如果要实现其特有的功能，单一模板就无法做到，这时就需要模板特例化
• 对单一模板提供的一个特殊实例，它将一个或多个模板参数绑定到特定的类型或值上
• 必须为原函数模板的每个模板参数都提供实参，且使用关键字template后跟一个空尖括号对<>，表明将原模板的所有模板参数提供实参，举例如下：

• 特例化的本质是实例化一个模板，而非重载它。特例化不影响参数匹配。参数匹配都以最佳匹配为原则。例如，此处如果是compare(3,5)，则调用普通的模板，若为compare(“hi”,”haha”)则调用特例化版本（因为这个cosnt char*相对于T，更匹配实参类型），注意二者函数体的语句不一样了，实现不同功能。
• 模板及其特例化版本应该声明在同一个头文件中，且所有同名模板的声明应该放在前面，后面放特例化版本。
• 原理类似函数模板，不过在类中，我们可以对模板进行特例化，也可以对类进行部分特例化。对类进行特例化时，仍然用template<>表示是一个特例化版本，例如：

• 不必为所有模板参数提供实参，可以指定一部分而非所有模板参数，一个类模板的部分特例化本身仍是一个模板，使用它时还必须为其特例化版本中未指定的模板参数提供实参(特例化时类名一定要和原来的模板相同，只是参数类型不同，按最佳匹配原则，哪个最匹配，就用相应的模板)
• 可以特例化类中的部分成员函数而不是整个类，举个例子：

• 《类和函数模板特例化》：

• 类型安全很大程度上可以等价于内存安全，类型安全的代码不会试图访问自己没被授权的内存区域。“类型安全”常被用来形容编程语言，其根据在于该门编程语言是否提供保障类型安全的机制；有的时候也用“类型安全”形容某个程序，判别的标准在于该程序是否隐含类型错误。类型安全的编程语言与类型安全的程序之间，没有必然联系。好的程序员可以使用类型不那么安全的语言写出类型相当安全的程序，相反的，差一点儿的程序员可能使用类型相当安全的语言写出类型不太安全的程序。绝对类型安全的编程语言暂时还没有。
• C只在局部上下文中表现出类型安全，比如试图从一种结构体的指针转换成另一种结构体的指针时，编译器将会报告错误，除非使用显式类型转换。然而，C中相当多的操作是不安全的。以下是两个十分常见的例子：

• 上述代码中，使用%d控制整型数字的输出，没有问题，但是改成%f时，明显输出错误，再改成%s时，运行直接报segmentation fault错误
• malloc是C中进行内存分配的函数，它的返回类型是void*即空类型指针，常常有这样的用法char* pStr=(char*)malloc(100*sizeof(char))，这里明显做了显式的类型转换。类型匹配尚且没有问题，但是一旦出现int*
• （2）C++的类型安全
• 如果C++使用得当，它将远比C更有类型安全性。相比于C语言，C++提供了一些新的机制保障类型安全：
• 操作符new返回的指针类型严格与对象匹配，而不是void*
• C中很多以void*为参数的函数可以改写为C++模板函数，而模板是支持类型检查的；
• 一些#define宏可被改写为inline函数，结合函数的重载，可在类型安全的前提下支持多种类型，当然改写为模板也能保证类型安全
• 例1：使用void*进行类型转换

• 例2：不同类型指针之间转换

• 上面两个例子之所以引起类型不安全的问题，是因为程序员使用不得当。第一个例子用到了空类型指针void*，第二个例子则是在两个类型指针之间进行强制转换。因此，想保证程序的类型安全性，应尽量避免使用空类型指针void*，尽量不对两种类型指针做强制转换。

为什么析构函数一般写成虚函数?

• 由于类的多态性，基类指针可以指向派生类的对象，如果删除该基类的指针，就会调用该指针指向的派生类析构函数，而派生类的析构函数又自动调用基类的析构函数，这样整个派生类的对象完全被释放。如果析构函数不被声明成虚函数，则编译器实施静态绑定，在删除基类指针时，只会调用基类的析构函数而不调用派生类析构函数，这样就会造成派生类对象析构不完全，造成内存泄漏。所以将析构函数声明为虚函数是十分必要的。在实现多态时，当用基类操作派生类，在析构时防止只析构基类而不析构派生类的状况发生，要将基类的析构函数声明为虚函数。举个例子：

• 将基类的析构函数声明为虚函数：

构造函数能否声明为虚函数或者纯虚函数，析构函数呢？

• 析构函数可以为虚函数，并且一般情况下基类析构函数要定义为虚函数。
• 只有在基类析构函数定义为虚函数时，调用操作符delete销毁指向对象的基类指针时，才能准确调用派生类的析构函数（从该级向上按序调用虚函数），才能准确销毁数据。
• 析构函数可以是纯虚函数，含有纯虚函数的类是抽象类，此时不能被实例化。但派生类中可以根据自身需求重新改写基类中的纯虚函数。

• 构造函数不能定义为虚函数。在构造函数中可以调用虚函数，不过此时调用的是正在构造的类中的虚函数，而不是子类的虚函数，因为此时子类尚未构造好。

C++中的重载、重写（覆盖）和隐藏的区别

• 重载是指在同一范围定义中的同名成员函数才存在重载关系。主要特点是函数名相同，参数类型和数目有所不同，不能出现参数个数和类型均相同，仅仅依靠返回值不同来区分的函数。重载和函数成员是否是虚函数无关。举个例子：

• （2）重写（覆盖）（override）
• 重写指的是在派生类中覆盖基类中的同名函数，重写就是重写函数体，要求基类函数必须是虚函数且：
  
• 与基类的虚函数有相同的参数个数
• 与基类的虚函数有相同的参数类型
• 与基类的虚函数有相同的返回值类型

• 重写是父类和子类之间的垂直关系，重载是不同函数之间的水平关系
• 重写要求参数列表相同，重载则要求参数列表不同，返回值不要求
• 重写关系中，调用方法根据对象类型决定，重载根据调用时实参表与形参表的对应关系来选择函数体

• （3）隐藏（hide）
• 隐藏指的是某些情况下，派生类中的函数屏蔽了基类中的同名函数，包括以下情况：
• 两个函数参数相同，但是基类函数不是虚函数。和重写的区别在于基类函数是否是虚函数。举个例子：

• 两个函数参数不同，无论基类函数是不是虚函数，都会被隐藏。和重载的区别在于两个函数不在同一个类中。举个例子：

• C++的多态性，一言以蔽之就是：
• 在基类的函数前加上virtual关键字，在派生类中重写该函数，运行时将会根据所指对象的实际类型来调用相应的函数，如果对象类型是派生类，就调用派生类的函数，如果对象类型是基类，就调用基类的函数 举个例子：

• 例子中，Base为基类，其中的函数为虚函数。子类1继承并重写了基类的函数，子类2继承基类但没有重写基类的函数，从结果分析子类体现了多态性，那么为什么会出现多态性，其底层的原理是什么？这里需要引出虚表和虚基表指针的概念。
• 虚表：虚函数表的缩写，类中含有virtual关键字修饰的方法时，编译器会自动生成虚表
• 虚表指针：在含有虚函数的类实例化对象时，对象地址的前四个字节存储的指向虚表的指针
  

• 上图中展示了虚表和虚表指针在基类对象和派生类对象中的模型，下面阐述实现多态的过程：
• (1)编译器在发现基类中有虚函数时，会自动为每个含有虚函数的类生成一份虚表，该表是一个一维数组，虚表里保存了虚函数的入口地址
• (2)编译器会在每个对象的前四个字节中保存一个虚表指针，即vptr，指向对象所属类的虚表。在构造时，根据对象的类型去初始化虚指针vptr，从而让vptr指向正确的虚表，从而在调用虚函数时，能找到正确的函数
• (3)所谓的合适时机，在派生类定义对象时，程序运行会自动调用构造函数，在构造函数中创建虚表并对虚表初始化。在构造子类对象时，会先调用父类的构造函数，此时，编译器只“看到了”父类，并为父类对象初始化虚表指针，令它指向父类的虚表；当调用子类的构造函数时，为子类对象初始化虚表指针，令它指向子类的虚表
• (4)当派生类对基类的虚函数没有重写时，派生类的虚表指针指向的是基类的虚表；当派生类对基类的虚函数重写时，派生类的虚表指针指向的是自身的虚表；当派生类中有自己的虚函数时，在自己的虚表中将此虚函数地址添加在后面
• 这样指向派生类的基类指针在运行时，就可以根据派生类对虚函数重写情况动态的进行调用，从而实现多态性。
• 《C++实现多态的原理》：

C++有哪几种的构造函数?

• C++中的构造函数可以分为4类：
• 初始化构造函数（有参数）
• 移动构造函数（move和右值引用）

• 默认构造函数和初始化构造函数在定义类的对象，完成对象的初始化工作
• 复制构造函数用于复制本类的对象
• 转换构造函数用于将其他类型的变量，隐式转换为本类对象
• 《浅谈C++中的几种构造函数》：

浅拷贝和深拷贝的区别??

• 浅拷贝只是拷贝一个指针，并没有新开辟一个地址，拷贝的指针和原来的指针指向同一块地址，如果原来的指针所指向的资源释放了，那么再释放浅拷贝的指针的资源就会出现错误。
• 深拷贝不仅拷贝值，还开辟出一块新的空间用来存放新的值，即使原先的对象被析构掉，释放内存了也不会影响到深拷贝得到的值。在自己实现拷贝赋值的时候，如果有指针变量的话是需要自己实现深拷贝的。

• 从执行结果可以看出，浅拷贝在对象的拷贝创建时存在风险，即被拷贝的对象析构释放资源之后，拷贝对象析构时会再次释放一个已经释放的资源，深拷贝的结果是两个对象之间没有任何关系，各自成员地址不同。
• 《C++面试题之浅拷贝和深拷贝的区别》：

内联函数和宏定义的区别??

• 内联(inline)函数和普通函数相比可以加快程序运行的速度，因为不需要中断调用，在编译的时候内联函数可以直接嵌入到目标代码中。
• 使用宏定义的地方都可以使用inline函数
• 作为类成员接口函数来读写类的私有成员或者保护成员，会提高效率

• 为什么不能把所有的函数写成内联函数
• 内联函数以代码复杂为代价，它以省去函数调用的开销来提高执行效率。所以一方面如果内联函数体内代码执行时间相比函数调用开销较大，则没有太大的意义；另一方面每一处内联函数的调用都要复制代码，消耗更多的内存空间，因此以下情况不宜使用内联函数：
• 函数体内的代码比较长，将导致内存消耗代价
• 函数体内有循环，函数执行时间要比函数调用开销大

• 内联函数在编译时展开，宏在预编译时展开
• 内联函数直接嵌入到目标代码中，宏是简单的做文本替换
• 内联函数有类型检测、语法判断等功能，而宏没有
• 内联函数是函数，宏不是
• 宏定义时要注意书写（参数要括起来）否则容易出现歧义，内联函数不会产生歧义
• 内联函数代码是被放到符号表中，使用时像宏一样展开，没有调用的开销，效率很高；
• 在使用时，宏只做简单字符串替换（编译前）。而内联函数可以进行参数类型检查（编译时），且具有返回值。
• 内联函数本身是函数，强调函数特性，具有重载等功能。
• 内联函数可以作为某个类的成员函数，这样可以使用类的保护成员和私有成员，进而提升效率。而当一个表达式涉及到类保护成员或私有成员时，宏就不能实现了。

构造函数、析构函数、虚函数可否声明为内联函数？

• 首先，将这些函数声明为内联函数，在语法上没有错误。因为inline同register一样，只是个建议，编译器并不一定认为是真正的内联。
• **register关键字：这个关键字请求编译器尽可能的将变量存在CPU内部寄存器中，而不是通过内存寻址访问，以提高效率 **

• 构造函数和析构函数声明为内联函数是没有意义的
C++》中所阐述的是：将构造函数和析构函数声明为inline是没有什么意义的，即编译器并不真正对声明为inline的构造和析构函数进行内联操作，因为编译器会在构造和析构函数中添加额外的操作（申请/释放内存，构造/析构对象等），致使构造函数/析构函数并不像看上去的那么精简。其次，class中的函数默认是inline型的，编译器也只是有选择性的inline，将构造函数和析构函数声明为内联函数是没有什么意义的。
• 将虚函数声明为inline，要分情况讨论
• 有的人认为虚函数被声明为inline，但是编译器并没有对其内联，他们给出的理由是inline是编译期决定的，而虚函数是运行期决定的，即在不知道将要调用哪个函数的情况下，如何将函数内联呢？
• 上述观点看似正确，其实不然，如果虚函数在编译器就能够决定将要调用哪个函数时，就能够内联，那么什么情况下编译器可以确定要调用哪个函数呢，答案是当用对象调用虚函数（此时不具有多态性）时，就内联展开
• 综上，当是指向派生类的指针（多态性）调用声明为inline的虚函数时，不会内联展开；当是对象本身调用虚函数时，会内联展开，当然前提依然是函数并不复杂的情况下
• 《构造函数、析构函数、虚函数可否内联，有何意义》：

• C++11新标准引入了auto类型说明符，用它就能让编译器替我们去分析表达式所属的类型。和原来那些只对应某种特定的类型说明符(例如 int)不同，
• auto 让编译器通过初始值来进行类型推演。从而获得定义变量的类型，所以说 auto 定义的变量必须有初始值。举个例子：

• 有的时候我们还会遇到这种情况，我们希望从表达式中推断出要定义变量的类型，但却不想用表达式的值去初始化变量。还有可能是函数的返回类型为某表达式的值类型。在这些时候auto显得就无力了，所以C++11又引入了第二种类型说明符decltype，它的作用是选择并返回操作数的数据类型。在此过程中，编译器只是分析表达式并得到它的类型，却不进行实际的计算表达式的值。

• decltype(auto)是C++14新增的类型指示符，可以用来声明变量以及指示函数返回类型。在使用时，会将“=”号左边的表达式替换掉auto，再根据decltype的语法规则来确定类型。举个例子：

• public的变量和函数在类的内部外部都可以访问。
• protected的变量和函数只能在类的内部和其派生类中访问。
• private修饰的元素只能在类内访问。
• 派生类可以继承基类中除了构造/析构、赋值运算符重载函数之外的成员，但是这些成员的访问属性在派生过程中也是可以调整的，三种派生方式的访问权限如下表所示：注意外部访问并不是真正的外部访问，而是在通过派生类的对象对基类成员的访问。
• 派生类可以继承基类中除了构造/析构、赋值运算符重载函数之外的成员，但是这些成员的访问属性在派生过程中也是可以调整的，三种派生方式的访问权限如下表所示：注意外部访问并不是真正的外部访问，而是在通过派生类的对象对基类成员的访问。

• 派生类对基类成员的访问形象有如下两种：
• 内部访问：由派生类中新增的成员函数对从基类继承来的成员的访问
  外部访问：在派生类外部，通过派生类的对象对从基类继承来的成员的访问

公有继承的特点是基类的公有成员和保护成员作为派生类的成员时，都保持原有的状态，而基类的私有成员任然是私有的，不能被这个派生类的子类所访问

保护继承的特点是基类的所有公有成员和保护成员都成为派生类的保护成员，并且只能被它的派生类成员函数或友元函数访问，基类的私有成员仍然是私有的.

私有继承的特点是基类的所有公有成员和保护成员都成为派生类的私有成员，并不被它的派生类的子类所访问，基类的成员只能由自己派生类访问，无法再往下继承，访问规则如下表

如何用代码判断大小端存储？？？

• 大端存储：字数据的高字节存储在低地址中
• 小端存储：字数据的低字节存储在低地址中
• 所以在Socket编程中，往往需要将操作系统所用的小端存储的IP地址转换为大端存储，这样才能进行网络传输

• 了解了大小端存储的方式，如何在代码中进行判断呢？下面介绍两种判断方式：
• 方式一：使用强制类型转换-这种法子不错

• 方式二：巧用union联合体

• 《写程序判断系统是大端序还是小端序》：

• (1)volatile 作用：保证程序可见性，禁止指令重排序
• volatile 关键字是一种类型修饰符，用它声明的类型变量表示可以被某些编译器未知的因素更改，比如：操作系统、硬件或者其它线程等。遇到这个关键字声明的变量，编译器对访问该变量的代码就不再进行优化，从而可以提供对特殊地址的稳定访问。
• 当要求使用 volatile 声明的变量的值的时候，系统总是重新从它所在的内存读取数据，即使它前面的指令刚刚从该处读取过数据。
• volatile定义变量的值是易变的，每次用到这个变量的值的时候都要去重新读取这个变量的值，而不是读寄存器内的备份。多线程中被几个任务共享的变量需要定义为volatile类型。

• 除了基本类型外，对用户定义类型也可以用volatile类型进行修饰。
• C++中一个有volatile标识符的类只能访问它接口的子集，一个由类的实现者控制的子集。用户只能用const_cast来获得对类型接口的完全访问。此外，volatile向const一样会从类传递到它的成员。

• 有些变量是用volatile关键字声明的。当两个线程都要用到某一个变量且该变量的值会被改变时，应该用volatile声明，该关键字的作用是防止优化编译器把变量从内存装入CPU寄存器中。如果变量被装入寄存器，那么两个线程有可能一个使用内存中的变量，一个使用寄存器中的变量，这会造成程序的错误执行。volatile的意思是让编译器每次操作该变量时一定要从内存中真正取出，而不是使用已经存在寄存器中的值。
• mutable的中文意思是“可变的，易变的”，跟constant（既C++中的const）是反义词。在C++中，mutable也是为了突破const的限制而设置的。被mutable修饰的变量，将永远处于可变的状态，即使在一个const函数中。我们知道，如果类的成员函数不会改变对象的状态，那么这个成员函数一般会声明成const的。但是，有些时候，我们需要在const函数里面修改一些跟类状态无关的数据成员，那么这个函数就应该被mutable来修饰，并且放在函数后后面关键字位置。
• explicit关键字用来修饰类的构造函数，被修饰的构造函数的类，不能发生相应的隐式类型转换，只能以显示的方式进行类型转换，注意以下几点：
• explicit 关键字只能用于类内部的构造函数声明上
• explicit 关键字作用于单个参数的构造函数
• 被explicit修饰的构造函数的类，不能发生相应的隐式类型转换

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

• 用类的一个实例化对象去初始化另一个对象的时候
• 函数的参数是类的对象时（非引用传递）
• 函数的返回值是函数体内局部对象的类的对象时 ,此时虽然发生（Named return Value优化）NRV优化，但是由于返回方式是值传递，所以会在返回值的地方调用拷贝构造函数
• 另：第三种情况在Linux g++ 下则不会发生拷贝构造函数，不仅如此即使返回局部对象的引用，依然不会发生拷贝构造函数
• 总结就是：即使发生NRV优化的情况下，Linux+ g++的环境是不管值返回方式还是引用方式返回的方式都不会发生拷贝构造函数，而Windows + VS2019在值返回的情况下发生拷贝构造函数，引用返回方式则不发生拷贝构造函数。
• 在c++编译器发生NRV优化，如果是引用返回的形式则不会调用拷贝构造函数，如果是值传递的方式依然会发生拷贝构造函数。
• 在VS2019下进行下述实验：

• 情况2的实现过程是，调用函数时先根据传入的实参产生临时对象，再用拷贝构造去初始化这个临时对象，在函数中与形参对应，函数调用结束后析构临时对象
• 情况3在执行return时，理论的执行过程是：产生临时对象，调用拷贝构造函数把返回对象拷贝给临时对象，函数执行完先析构局部变量，再析构临时对象， 依然会调用拷贝构造函数
• 《C++拷贝构造函数详解》：

• 言下之意就是普通的new，就是我们常用的new，在C++中定义如下：

• 因此plain new在空间分配失败的情况下，抛出异常std::bad_alloc而不是返回NULL，因此通过判断返回值是否为NULL是徒劳的，举个例子：

• （2）nothrow new nothrow new在空间分配失败的情况下是不抛出异常，而是返回NULL，定义如下：

• （3）placement new 这种new允许在一块已经分配成功的内存上重新构造对象或对象数组。placement new不用担心内存分配失败，因为它根本不分配内存，它做的唯一一件事情就是调用对象的构造函数。定义如下：

• palcement new的主要用途就是反复使用一块较大的动态分配的内存来构造不同类型的对象或者他们的数组
• placement new构造起来的对象数组，要显式的调用他们的析构函数来销毁（析构函数并不释放对象的内存），千万不要使用delete，这是因为placement new构造起来的对象或数组大小并不一定等于原来分配的内存大小，使用delete会造成内存泄漏或者之后释放内存时出现运行时错误。

• 《【C++】几种类型的new介绍》：

• 算是为了与C语言进行兼容而定义的一个问题吧
• NULL来自C语言，一般由宏定义实现，而 nullptr 则是C++11的新增关键字。在C语言中，NULL被定义为(void)0,而在C++语言中，NULL则被定义为整数0*。编译器一般对其实际定义如下：

• 在C++中指针必须有明确的类型定义。但是将NULL定义为0带来的另一个问题是无法与整数的0区分。因为C++中允许有函数重载，所以可以试想如下函数定义情况：

• 那么在传入NULL参数时，会把NULL当做整数0来看，如果我们想调用参数是指针的函数，该怎么办呢?。nullptr在C++11被引入用于解决这一问题，nullptr可以明确区分整型和指针类型，能够根据环境自动转换成相应的指针类型，但不会被转换为任何整型，所以不会造成参数传递错误。
• nullptr的一种实现方式如下：

• 以上通过模板类和运算符重载的方式来对不同类型的指针进行实例化从而解决了(void*)指针带来参数类型不明的问题，另外由于nullptr是明确的指针类型，所以不会与整形变量相混淆。但nullptr仍然存在一定问题，例如：

• 在这种情况下存在对不同指针类型的函数重载，此时如果传入nullptr指针则仍然存在无法区分应实际调用哪个函数，这种情况下必须显示的指明参数类型。

简要说明C++的内存分区

C++中的内存分区，分别是堆、栈、自由存储区、全局/静态存储区、常量存储区和代码区。如下图所示

• 栈：在执行函数时，函数内局部变量的存储单元都可以在栈上创建，函数执行结束时这些存储单元自动被释放。栈内存分配运算内置于处理器的指令集中，效率很高，但是分配的内存容量有限
• 堆：就是那些由 new分配的内存块，他们的释放编译器不去管，由我们的应用程序去控制，一般一个new就要对应一个 delete。如果程序员没有释放掉，那么在程序结束后，操作系统会自动回收
• 自由存储区：就是那些由malloc等分配的内存块，它和堆是十分相似的，不过它是用free来结束自己的生命的
• 全局/静态存储区：全局变量和静态变量被分配到同一块内存中，在以前的C语言中，全局变量和静态变量又分为初始化的和未初始化的，在C++里面没有这个区分了，它们共同占用同一块内存区，在该区定义的变量若没有初始化，则会被自动初始化，例如int型变量自动初始为0
• 常量存储区：这是一块比较特殊的存储区，这里面存放的是常量，不允许修改
• 代码区：存放函数体的二进制代码
• 《C/C++内存管理详解》：

C++的异常处理的方法

在程序执行过程中，由于程序员的疏忽或是系统资源紧张等因素都有可能导致异常，任何程序都无法保证绝对的稳定，常见的异常有：

• 动态分配空间时空间不足
• … 如果不及时对这些异常进行处理，程序多数情况下都会崩溃。
• C++中的异常处理机制主要使用try、throw和catch三个关键字，其在程序中的用法如下：

• 代码中，对两个数进行除法计算，其中除数为0。可以看到以上三个关键字，程序的执行流程是先执行try包裹的语句块，如果执行过程中没有异常发生，则不会进入任何catch包裹的语句块。如果发生异常，则使用throw进行异常抛出，再由catch进行捕获，throw可以抛出各种数据类型的信息，代码中使用的是数字，也可以自定义异常class。
• catch根据throw抛出的数据类型进行精确捕获（不会出现类型转换），如果匹配不到就直接报错，可以使用catch(…)的方式捕获任何异常（不推荐）。
• 当然，如果catch了异常，当前函数如果不进行处理，或者已经处理了想通知上一层的调用者，可以在catch里面再throw异常。
• （2）函数的异常声明列表 有时候，程序员在定义函数的时候知道函数可能发生的异常，可以在函数声明和定义时，指出所能抛出异常的列表，写法如下：

• 这种写法表名函数可能会抛出int,double型或者A、B、C三种类型的异常，如果throw中为空，表明不会抛出任何异常，如果没有throw则可能抛出任何异常
• （3）C++标准异常类 exception C++ 标准库中有一些类代表异常，这些类都是从 exception 类派生而来的，如下图所示

• bad_typeid：使用typeid运算符，如果其操作数是一个多态类的指针，而该指针的值为 NULL，则会拋出此异常，例如：

• bad_cast：在用 dynamic_cast 进行从多态基类对象（或引用）到派生类的引用的强制类型转换时，如果转换是不安全的，则会拋出此异常
• bad_alloc：在用 new 运算符进行动态内存分配时，如果没有足够的内存，则会引发此异常

内容比较分散，显得杂乱，有空持续更新