C++重点知识

1.什么是虚函数？什么是纯虚函数？

虚函数是允许被其子类重新定义的成员函数。
虚函数的声明：virtual returntype func(parameter);引入虚函数的目的是为了动态绑定；

纯虚函数声明：virtual returntype func(parameter)=0；引入纯虚函数是为了派生接口。（使派生类仅仅只是继承函数的接口）

2.基类为什么需要虚析构函数？

防止内存泄漏。想去借助父类指针去销毁子类对象的时候，不能去销毁子类对象。假如没有虚析构函数，释放一个由基类指针指向的派生类对象时，不会触发动态绑定，则只会调用基类的析构函数，不会调用派生类的。派生类中申请的空间则得不到释放导致内存泄漏。

3.当i是一个整数的时候i++和++i那个更快？它们的区别是什么？

几乎一样。i++先返回 i 的值，然后将 i 加1，++i 先将 i 自加1，再返回 i 的引用，即 ++i 是一个确定的值，是一个可以修改的左值。

4.vector的reserve和capacity

reserve()用于让容器预留空间，避免多次次分配内存；
capacity()返回所能容纳的元素数量，并不是当前的元素数量。

5.如何初始化const和static数据成员？

通常在类中声明static成员，在类外初始化它，但是static const的整型（bool，char，int，long）可以在类中声明且初始化，static const的其他类型必须在类外初始化（包括整型数组）。

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

对变量：

1.局部变量：

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

1）内存中的位置：静态存储区

2）初始化：未经初始化的全局静态变量会被程序自动初始化为0（自动对象的值是任意的，除非他被显示初始化）

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

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

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

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

2）初始化：未经初始化的全局静态变量会被程序自动初始化为0（自动对象的值是任意的，除非他被显示初始化）

3）作用域：全局静态变量在声明他的文件之外是不可见的。准确地讲从定义之处开始到文件结尾。

注：static修饰全局变量，并未改变其存储位置及生命周期，而是改变了其作用域，使当前文件外的源文件无法访问该变量，好处如下：（1）不会被其他文件所访问，修改（2）其他文件中可以使用相同名字的变量，不会发生冲突。对全局函数也是有隐藏作用。而普通全局变量只要定义了，任何地方都能使用，使用前需要声明所有的.c文件，只能定义一次普通全局变量，但是可以声明多次（外部链接）。注意：全局变量的作用域是全局范围，但是在某个文件中使用时，必须先声明。

对类中的：

1.成员变量
　　　用static修饰类的数据成员实际使其成为类的全局变量，会被类的所有对象共享，包括派生类的对象。因此，static成员必须在类外进行初始化(初始化格式： int base::var=10;)，而不能在构造函数内进行初始化，不过const修饰static数据成员在类内可以初始化 。因为静态成员属于整个类，而不属于某个对象，如果在类内初始化，会导致每个对象都包含该静态成员，这是矛盾的。

    特点：

     1.不要试图在头文件中定义(初始化)静态数据成员。在大多数的情况下，这样做会引起重复定义这样的错误。即使加上#ifndef #define #endif或者#pragma once也不行。 

     2.静态数据成员可以成为成员函数的可选参数，而普通数据成员则不可以。？？？

     3.静态数据成员的类型可以是所属类的类型，而普通数据成员则不可以。普通数据成员的只能声明为 所属类类型的指针或引用。？？？
1
2
3
4
5
6
7

2.成员函数

不可以同时用const和static修饰成员函数。
用static修饰成员函数，使这个类只存在这一份函数，所有对象共享该函数，不含this指针。
静态成员是可以独立访问的，也就是说，无须创建任何对象实例就可以访问。base::func(5,3);当static成员函数在类外定义时不需要加static修饰符。
在静态成员函数的实现中不能直接引用类中说明的非静态成员，可以引用类中说明的静态成员。因为静态成员函数不含this指针。

C++编译器在实现const的成员函数的时候为了确保该函数不能修改类的实例的状态，会在函数中添加一个隐式的参数const this*。但当一个成员为static的时候，该函数是没有this指针的。也就是说此时const的用法和static是冲突的。

我们也可以这样理解：两者的语意是矛盾的。static的作用是表示该函数只作用在类型的静态变量上，与类的实例没有关系；而const的作用是确保函数不能修改类的实例的状态，与类型的静态变量没有关系。因此不能同时用它们。

const的作用：

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

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

3.const与指针：

const char *p 表示 指向的内容不能改变。

char * const p，就是将P声明为常指针，它的地址不能改变，是固定的，但是它的内容可以改变。

7.指针和引用的区别

本质上的区别是，指针是一个新的变量，只是这个变量存储的是另一个变量的地址，我们通过访问这个地址来修改变量。

而引用只是一个别名，还是变量本身。对引用进行的任何操作就是对变量本身进行操作，因此以达到修改变量的目的。

注：

(1)指针：指针是一个变量，只不过这个变量存储的是一个地址，指向内存的一个存储单元；而引用跟原来的变量实质上是同一个东西，只不过是原变量的一个别名而已。如：
int a=1;int *p=&a;
int a=1;int &b=a;
上面定义了一个整形变量和一个指针变量p，该指针变量指向a的存储单元，即p的值是a存储单元的地址。

而下面2句定义了一个整形变量a和这个整形a的引用b，事实上a和b是同一个东西，在内存占有同一个存储单元。

(2)可以有const指针，但是没有const引用（const引用可读不可改，与绑定对象是否为const无关）

**注：引用可以指向常量，也可以指向变量。例如int &a=b，使引用a指向变量b。而为了让引用指向常量，必须使用常量引用，如const int &a=1; 它代表的是引用a指向一个const int型，这个int型的值不能被改变，而不是引用a的指向不能被改变，因为引用的指向本来就是不可变的，无需加const声明。即指针存在常量指针int const p和指针常量int const p，而引用只存在常量引用int const &a，不存在引用常量int& const a。

8.什么是多态？多态有什么用途？

C++ 多态有两种：静态多态（早绑定）、动态多态（晚绑定）。静态多态是通过函数重载实现的；动态多态是通过虚函数实现的。

1.定义：“一个接口，多种方法”，程序在运行时才决定要调用的函数。

2.实现：C++多态性主要是通过虚函数实现的，虚函数允许子类重写override(注意和overload的区别，overload是重载，是允许同名函数的表现，这些函数参数列表/类型不同）。

注：静态与动态的实质区别就是函数地址是静态绑定还是动态绑定。如果函数的调用在编译器编译期间就可以确定函数的调用地址，并产生代码，说明地址是静态绑定的；如果函数调用的地址是 需要在运行期间才确定，属于动态绑定。

3.目的：接口重用。封装可以使得代码模块化，继承可以扩展已存在的代码，他们的目的都是为了代码重用。而多态的目的则是为了接口重用。

4.用法：声明基类的指针，利用该指针指向任意一个子类对象，调用相应的虚函数，可以根据指向的子类的不同而实现不同的方法。

用一句话概括：在基类的函数前加上virtual关键字，在派生类中重写该函数，运行时将会根据对象的实际类型来调用相应的函数。如果对象类型是派生类，就调用派生类的函数；如果对象类型是基类，就调用基类的函数。

关于重载、重写、隐藏的区别

Overload(重载)：在C++程序中，可以将语义、功能相似的几个函数用同一个名字表示，但参数或返回值不同（包括类型、顺序不同），即函数重载。
（1）相同的范围（在同一个类中）；
（2）函数名字相同；
（3）参数不同；
（4）virtual 关键字可有可无。

Override(覆盖或重写)：是指派生类函数覆盖基类函数，特征是：
（1）不同的范围（分别位于派生类与基类）；
（2）函数名字相同；
（3）参数相同；
（4）基类函数必须有virtual 关键字。
注：重写基类虚函数的时候，会自动转换这个函数为virtual函数，不管有没有加virtual，因此重写的时候不加virtual也是可以的，不过为了易读性，还是加上比较好。

Overwrite(重写)：隐藏，是指派生类的函数屏蔽了与其同名的基类函数，规则如下：
（1）如果派生类的函数与基类的函数同名，但是参数不同。此时，不论有无virtual关键字，基类的函数将被隐藏（注意别与重载混淆）。
（2）如果派生类的函数与基类的函数同名，并且参数也相同，但是基类函数没有virtual关键字。此时，基类的函数被隐藏（注意别与覆盖混淆）。

虚函数表：
多态是由虚函数实现的，而虚函数主要是通过虚函数表（V-Table）来实现的。
如果一个类中包含虚函数（virtual修饰的函数），那么这个类就会包含一张虚函数表，虚函数表存储的每一项是一个虚函数的地址。如下图：

这个类的每一个对象都会包含一个虚指针（虚指针存在于对象实例地址的最前面，保证虚函数表有最高的性能），这个虚指针指向虚函数表。

注：对象不包含虚函数表，只有虚指针，类才包含虚函数表，派生类会生成一个兼容基类的虚函数表。

原始基类的虚函数表
下图是原始基类的对象，可以看到虚指针在地址的最前面，指向基类的虚函数表（假设基类定义了3个虚函数）

单继承时的虚函数（无重写基类虚函数）
　　 假设现在派生类继承基类，并且重新定义了3个虚函数，派生类会自己产生一个兼容基类虚函数表的属于自己的虚函数表。
　　
Derive Class继承了Base Class中的3个虚函数，准确说是该函数的实体地址被拷贝到Derive Class的虚函数列表中，派生新增的虚函数置于虚函数列表后面，并按声明顺序摆放。

单继承时的虚函数（重写基类虚函数）
现在派生类重写基类的x函数，可以看到这个派生类构建自己的虚函数表的时候，修改了base::x()这一项，指向了自己的虚函数。

多重继承时的虚函数（class Derived :public Base1,public Base2）
这个派生类多重继承了两个基类base1，base2，因此它有两个虚函数表。
　　

它的对象会有多个虚指针（据说和编译器相关），指向不同的虚函数表。

      注：有关以上虚函数表等详见c++对象模型。链接地址：https://www.cnblogs.com/inception6-lxc/p/9273918.html
1

纯虚函数：
定义： 在很多情况下，基类本身生成对象是不合情理的。为了解决这个问题，方便使用类的多态性，引入了纯虚函数的概念，将函数定义为纯虚函数（方法：virtual ReturnType Function()= 0;）纯虚函数不能再在基类中实现，编译器要求在派生类中必须予以重写以实现多态性。同时含有纯虚拟函数的类称为抽象类，它不能生成对象。称带有纯虚函数的类为抽象类。

	特点：
1

1，当想在基类中抽象出一个方法，且该基类只做能被继承，而不能被实例化；（避免类被实例化且在编译时候被发现，可以采用此方法）
　　2，这个方法必须在派生类(derived class)中被实现；
　　目的：使派生类仅仅只是继承函数的接口。
　　
9.vector中size()和capacity()的区别。
size()指容器当前拥有的元素个数（对应的resize(size_type)会在容器尾添加或删除一些元素，来调整容器中实际的内容，使容器达到指定的大小。）；capacity（）指容器在必须分配存储空间之前可以存储的元素总数。

size表示的这个vector里容纳了多少个元素，capacity表示vector能够容纳多少元素，它们的不同是在于vector的size是2倍增长的。如果vector的大小不够了，比如现在的capacity是4，插入到第五个元素的时候，发现不够了，此时会给他重新分配8个空间，把原来的数据及新的数据复制到这个新分配的空间里。（会有迭代器失效的问题）

10.new和malloc的区别。
new是运算符，malloc()是一个库函数；
new会调用构造函数，malloc不会；
new返回指定类型指针，malloc返回void*指针，需要强制类型转换；
new会自动计算需分配的空间，malloc不行；
new可以被重载，malloc不能。

11.C++的内存分区
栈区（stack）：主要存放函数参数以及局部变量，由系统自动分配释放。
堆区（heap）：由用户通过 malloc/new 手动申请，手动释放。注意它与数据结构中的堆是两回事，分配方式倒是类似于链表。
全局/静态区：存放全局变量、静态变量；程序结束后由系统释放。
字符串常量区：字符串常量就放在这里，程序结束后由系统释放。
代码区：存放程序的二进制代码。

12.vector、map、multimap、unordered_map、unordered_multimap的底层数据结构，以及几种map容器如何选择？
底层数据结构：

vector基于数组，map、multimap基于红黑树，unordered_map、unordered_multimap基于哈希表。
根据应用场景进行选择：

map/unordered_map 不允许重复元素
multimap/unordered_multimap 允许重复元素
map/multimap 底层基于红黑树，元素自动有序，且插入、删除效率高
unordered_map/unordered_multimap 底层基于哈希表，故元素无序，查找效率高。

13.内存泄漏怎么产生的？如何避免？
内存泄漏一般是指堆内存的泄漏，也就是程序在运行过程中动态申请的内存空间不再使用后没有及时释放，导致那块内存不能被再次使用。
更广义的内存泄漏还包括未对系统资源的及时释放，比如句柄、socket等没有使用相应的函数释放掉，导致系统资源的浪费。

#define CRTDBG_MAP_ALLOC
#include <stdlib.h>
#include <crtdbg.h>
//在入口函数中包含 _CrtDumpMemoryLeaks();
//即可检测到内存泄露

//以如下测试函数为例：
int main()
{
char* pChars = new char[10];
//delete[]pChars;
_CrtDumpMemoryLeaks();
system(“pause”);
return 0;
}

解决方法：

养成良好的编码习惯和规范，记得及时释放掉内存或系统资源。
重载new和delete，以链表的形式自动管理分配的内存。
使用智能指针，share_ptr、unique_ptr、weak_ptr。

14.说几个C++11的新特性

auto类型推导
范围for循环
lambda函数
override 和 final 关键字

/*如果不使用override，当你手一抖，将foo()写成了f00()会怎么样呢？结果是编译器并不会报错，因为它并不知道你的目的是重写虚函数，而是把它当成了新的函数。如果这个虚函数很重要的话，那就会对整个程序不利。

所以，override的作用就出来了，它指定了子类的这个虚函数是重写的父类的，如果你名字不小心打错了的话，编译器是不会编译通过的：*/
class A
{
virtual void foo();
}
class B :public A
{
void foo(); //OK
virtual foo(); // OK
void foo() override; //OK
}

class A
{
virtual void foo();
};
class B :A
{
virtual void f00(); //OK
virtual void f0o()override; //Error
};
/当不希望某个类被继承，或不希望某个虚函数被重写，可以在类名和虚函数后添加final关键字，添加final关键字后被继承或重写，编译器会报错。例子如下：/

class Base
{
virtual void foo();
};

class A : Base
{
void foo() final; // foo 被override并且是最后一个override，在其子类中不可以重写
void bar() final; // Error: 父类中没有 bar虚函数可以被重写或final
};

class B final : A // 指明B是不可以被继承的
{
void foo() override; // Error: 在A中已经被final了
};

class C : B // Error: B is final
{
};

空指针常量nullptr
线程支持、智能指针等

15.C和C++区别？
C++在C的基础上增添类，C是一个结构化语言，它的重点在于算法和数据结构。C程序的设计首要考虑的是如何通过一个过程，对输入（或环境条件）进行运算处理得到输出（或实现过程（事务）控制），而对于C++，首要考虑的是如何构造一个对象模型，让这个模型能够契合与之对应的问题域，这样就可以通过获取对象的状态信息得到输出或实现过程（事务）控制。

16.const与#define的区别
1.编译器处理方式
define – 在预处理阶段进行替换
const – 在编译时确定其值

2.类型检查
define – 无类型，不进行类型安全检查，可能会产生意想不到的错误
const – 有数据类型，编译时会进行类型检查

3.内存空间
define – 不分配内存，给出的是立即数，有多少次使用就进行多少次替换，在内存中会有多个拷贝，消耗内存大
const – 在静态存储区中分配空间，在程序运行过程中内存中只有一个拷贝

4.其他
在编译时， 编译器通常不为const常量分配存储空间，而是将它们保存在符号表中，这使得它成为一个编译期间的常量，没有了存储与读内存的操作，使得它的效率也很高。
宏替换只作替换，不做计算，不做表达式求解。

17.悬空指针与野指针区别
悬空指针：当所指向的对象被释放或者收回，但是没有让指针指向NULL；

18.struct与class的区别？
本质区别是访问的默认控制：默认的继承访问权限，class是private，struct是public；

19.sizeof和strlen的区别？
功能不同：

sizeof是操作符，参数为任意类型，主要计算类型占用内存大小。

strlen（）是函数，其函数原型为：extern unsigned int strlen(char s）;其参数为char,strlen只能计算以"\0"结尾字符串的长度，计算结果不包括"\0"。

参数不同：

当将字符数组作为sizeof（）的参数时，计算字符数组占用内存大小；当将字符数组作为strlen（)函数，字符数组转化为char*。因为sizeof的参数为任意类型，而strlen（）函数参数只能为char*，当参数不是char必须转换为char。

20.32位，64位系统中，各种常用内置数据类型占用的字节数？
char ：1个字节(固定)

(即指针变量): 4个字节(32位机的寻址空间是4个字节。同理64位编译器)(变化)

short int : 2个字节(固定)

int： 4个字节(固定)

unsigned int : 4个字节(固定)

float: 4个字节(固定)

double: 8个字节(固定)

long: 4个字节

unsigned long: 4个字节(变化*,其实就是寻址控件的地址长度数值)

long long: 8个字节(固定)

64位操作系统

char ：1个字节(固定)

*(即指针变量): 8个字节

short int : 2个字节(固定)

int： 4个字节(固定)

unsigned int : 4个字节(固定)

float: 4个字节(固定)

double: 8个字节(固定)

long: 8个字节

unsigned long: 8个字节(变化*其实就是寻址控件的地址长度数值)

long long: 8个字节(固定)

除*与long 不同其余均相同。

21.virtual, inline, decltype,volatile,static, const关键字的作用？使用场景？
inline：在c/c++中，为了解决一些频繁调用的小函数大量消耗栈空间（栈内存）的问题，特别的引入了inline修饰符，表示为内联函数。

decltype:从表达式中推断出要定义变量的类型，但却不想用表达式的值去初始化变量。还有可能是函数的返回类型为某表达式的的值类型。

volatile：volatile 关键字是一种类型修饰符，用它声明的类型变量表示可以被某些编译器未知的因素更改，比如：操作系统、硬件或者其它线程等。遇到这个关键字声明的变量，编译器对访问该变量的代码就不再进行优化，从而可以提供对特殊地址的稳定访问。

static:

隐藏
　　　　　　在变量和函数名前面如果未加static，则它们是全局可见的。加了static，就会对其它源文件隐藏，利用这一特性可以在不同的文件中定义同名函数和同名变量，而不必担心命名冲 突。static可以用作函数和变量的前缀，对于函数来讲，static的作用仅限于隐藏 。

2.static变量中的记忆功能和全局生存期

存储在静态数据区的变量会在程序刚开始运行时就完成初始化，也是唯一的一次初始化。共有两种变量存储在静态存储区：全局变量和static变量，只不过和全局变量比起来，static可以控制变量的可见范围，说到底static还是用来隐藏的。PS：如果作为static局部变量在函数内定义，它的生存期为整个源程序，但是其作用域仍与自动变量相同，只能在定义该变量的函数内使用该变量。退出该函数后， 尽管该变量还继续存在，但不能使用它。
　　　　22.深拷贝与浅拷贝的区别？
1.什么时候用到拷贝函数？

a.一个对象以值传递的方式传入函数体；
b.一个对象以值传递的方式从函数返回；
c.一个对象需要通过另外一个对象进行初始化。
如果在类中没有显式地声明一个拷贝构造函数，那么，编译器将会自动生成一个默认的拷贝构造函数，该构造函数完成对象之间的位拷贝。位拷贝又称浅拷贝；

2.是否应该自定义拷贝函数？

自定义拷贝构造函数是一种良好的编程风格，它可以阻止编译器形成默认的拷贝构造函数，提高源码效率。

3.什么叫深拷贝？什么是浅拷贝？两者异同？

如果一个类拥有资源，当这个类的对象发生复制过程的时候，资源重新分配，这个过程就是深拷贝，反之，没有重新分配资源，就是浅拷贝。
4.深拷贝好还是浅拷贝好？

如果实行位拷贝，也就是把对象里的值完全复制给另一个对象，如A=B。这时，如果B中有一个成员变量指针已经申请了内存，那A中的那个成员变量也指向同一块内存。这就出现了问题：当B把内存释放了（如：析构），这时A内的指针就是野指针了，出现运行错误。

参考博客：https://blog.csdn.net/caoshangpa/article/details/79226270

              http://www.cnblogs.com/BlueTzar/articles/1223313.html
1

23.派生类中构造函数，析构函数调用顺序？
构造函数：“先基后派”；析构函数：“先派后基”。

24.C++类中数据成员初始化顺序？

1.成员变量在使用初始化列表初始化时，与构造函数中初始化成员列表的顺序无关，只与定义成员变量的顺序有关。

2.如果不使用初始化列表初始化，在构造函数内初始化时，此时与成员变量在构造函数中的位置有关。

3.类中const成员常量必须在构造函数初始化列表中初始化。

4.类中static成员变量，只能在类内外初始化(同一类的所有实例共享静态成员变量)。
初始化顺序：

1） 基类的静态变量或全局变量
2） 派生类的静态变量或全局变量
3） 基类的成员变量
4） 派生类的成员变量

25.结构体内存对齐问题？结构体/类大小的计算？
注：内存对齐是看类型，而不是看总的字节数。比如：

	#include<iostream>
	using namespace std;
	
	struct AlignData1
	{
	    int a;
	    char b[7];	//和d一起
	    short c;
	    char d;
	}Node;
	struct AlignData2
	{
	    bool a;	//补3个对齐
	    int b[2];//a
	    int c;
	    int d;
	}Node2;
	int main(){
	    cout << sizeof(Node) << endl;//16
	    cout << sizeof(Node2) << endl;//20
	    system("pause");
	    return 0;
	}```

补充：

每个成员相对于这个结构体变量地址的偏移量正好是该成员类型所占字节的整数倍。为了对齐数据，可能必须在上一个数据结束和下一个数据开始的地方插入一些没有用处字节。
最终占用字节数为成员类型中最大占用字节数的整数倍。
一般的结构体成员按照默认对齐字节数递增或是递减的顺序排放，会使总的填充字节数最少。

补充：联合体的大小计算：

联合体所占的空间不仅取决于最宽成员，还跟所有成员有关系，即其大小必须满足两个条件：1)大小足够容纳最宽的成员；2)大小能被其包含的所有基本数据类型的大小所整除。

	```cpp
	union U1  
	{  
	    int n;  
	    char s[11];  
	    double d;  
	};  //16，char s[11]按照char=1可以整除
	  
	union U2  
	{  
	    int n;  
	    char s[5];  
	    double d;  
	};  //8
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48

26.static_cast, dynamic_cast, const_cast, reinpreter_cast的区别？

cast发生的时间不同，一个是static编译时，一个是runtime运行时；
static_cast是相当于C的强制类型转换，用起来可能有一点危险，不提供运行时的检查来确保转换的安全性。
dynamic_cast用于转换指针和和引用，不能用来转换对象 ——主要用于类层次间的上行转换和下行转换，还可以用于类之间的交叉转换。在类层次间进行上行转换时，dynamic_cast和static_cast的效果是一样的；在进行下行转换时，dynamic_cast具有类型检查的功能，比static_cast更安全。在多态类型之间的转换主要使用dynamic_cast，因为类型提供了运行时信息。

#include <iostream> 
using namespace std; 
class CBasic 
{ 
public: 
     virtual int test(){return 0;} 
}; 

class CDerived : public CBasic 
{ 
public: 
     virtual int test(){ return 1;} 
}; 
  
int main() 
{ 
     CBasic        cBasic; 
     CDerived    cDerived; 
     CBasic * pB1 = new CBasic; 
     CBasic * pB2 = new CDerived;
     CBasic * pB3 = new CBasic;
     CBasic * pB4 = new CDerived;
     
     
     //dynamic cast failed, so pD1 is null. 
     CDerived * pD1 = dynamic_cast<CDerived * > (pB1);    
                  
     //dynamic cast succeeded, so pD2 points to  CDerived object                                         
     CDerived * pD2 = dynamic_cast<CDerived * > (pB2);
     //pD3将是一个指向该CBasic类型对象的指针，对它进行CDerive类型的操作将是不安全的
     CDerived * pD3 = static_cast<CDerived * > (pB3);     
     //static_cast成功
     CDerived * pD4 = static_cast<CDerived * > (pB4);      
      
     //dynamci cast failed, so throw an exception.             
//    CDerived & rD1 = dynamic_cast<CDerived &> (*pB1);    
  
//dynamic cast succeeded, so rD2 references to CDerived object. 
     CDerived & rD2 = dynamic_cast<CDerived &> (*pB2);    
  
     return 0; 
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42

注：CBasic要有虚函数，否则会编译出错；static_cast则没有这个限制。

27.智能指针
智能指针是在 头文件中的std命名空间中定义的，该指针用于确保程序不存在内存和资源泄漏且是异常安全的。它们对RAII“获取资源即初始化”编程至关重要，RAII的主要原则是将任何堆分配资源（如动态分配内存或系统对象句柄）的所有权提供给其析构函数包含用于删除或释放资源的代码以及任何相关清理代码的堆栈分配对象。大多数情况下，当初始化原始指针或资源句柄以指向实际资源时，会立即将指针传递给智能指针。

28.计算类大小例子
class A {};: sizeof(A) = 1;
class A { virtual Fun(){} };: sizeof(A) = 4(32位机器)/8(64位机器);
class A { static int a; };: sizeof(A) = 1;
class A { int a; };: sizeof(A) = 4;
class A { static int a; int b; };: sizeof(A) = 4;

类中用static声明的成员变量不计算入类的大小中，因为static data不是实例的一部分。static的属于全局的，他不会占用类的存储，他有专门的地方存储 （全局变量区）

29.大端与小端的概念？各自的优势是什么？
大端与小端是用来描述多字节数据在内存中的存放顺序，即字节序。大端（Big Endian）指低地址端存放高位字节，小端（Little Endian）是指低地址端存放低位字节。
需要记住计算机是以字节为存储单位。
为了方便记忆可把大端和小端称作高尾端和低尾端，eg：如果是高尾端模式一个字符串“11223344”把尾部“44”放在地址的高位，如果是地尾端模式，把“44”放在地址的低位。
各自优势：

Big Endian：符号位的判定固定为第一个字节，容易判断正负。
Little Endian：长度为1，2，4字节的数，排列方式都是一样的，数据类型转换非常方便。

30.C++中*和&同时使用是什么意思?
template
void InsertFront(Node* & head, T item)
上面一个函数的声明，其中第一个参数*和&分别是什么意思？
head是个指针，前面为什么加个&

本来“* head”代表的是传指针的，但是只能改变head指向的内容，而“* &head”意思是说head是传进来的指针的同名指针，就能既改变head指向的内容，又能改变head这个指针。比如：main()有个Node p,int t；当调用insertFront(p,t)是，如果template void InsertFront(Node* & head, T item)中有对head进行赋值改变时，main()中的p也会跟着改变，如果没有&这个别名标识时，p则不会随着head的改变而改变。

31.C++vector与list区别
1.vector数据结构
vector和数组类似，拥有一段连续的内存空间，并且起始地址不变。
因此能高效的进行随机存取，时间复杂度为o(1);
但因为内存空间是连续的，所以在进行插入和删除操作时，会造成内存块的拷贝，时间复杂度为o(n)。
另外，当数组中内存空间不够时，会重新申请一块内存空间并进行内存拷贝。
2.list数据结构
list是由双向链表实现的，因此内存空间是不连续的。
只能通过指针访问数据，所以list的随机存取非常没有效率，时间复杂度为o(n);
但由于链表的特点，能高效地进行插入和删除。

3.vector和list的区别
vector拥有一段连续的内存空间，能很好的支持随机存取，
因此vector::iterator支持“+”，“+=”，“<”等操作符。

list的内存空间可以是不连续，它不支持随机访问，
因此list::iterator则不支持“+”、“+=”、“<”等

vector::iterator和list::iterator都重载了“++”运算符。

总之，如果需要高效的随机存取，而不在乎插入和删除的效率，使用vector;
如果需要大量的插入和删除，而不关心随机存取，则应使用list。

32.C语言中static关键字作用
在C语言中static的作用如下

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

静态成员函数
（1）静态成员函数和静态数据成员一样，他们都属于类的静态成员，而不是对象成员。
（2）非静态成员函数有this指针，而静态成员函数没有this指针。
（3）静态成员函数主要用来访问静态数据成员而不能访问非静态成员。

33.C/C++中堆和栈的区别
一、数据结构中的堆和栈

   堆和栈在数据结构中是两种不同的数据结构。 两者都是数据项按序排列的数据结构。
   栈是一种具有后进先出的数据结构
   堆是一种经过排序的树形数据结构，每个节点都有一个值。通常我们所说的堆的数据结构是指二叉树。堆的特点是根节点的值最小（或最大），且根节点的两个树也是一个堆。由于堆的这个特性，常用来实现优先队列，堆的存取是随意的。
1
2
3

二、内存分配中的堆和栈
一般情况下程序存放在Rom或Flash中，运行事需要拷贝到内存中执行，内存会分别存储不同的信息。内存中的栈区处于相对较高的地址，以地址的增长方向为上的话，栈地址是向下增长的。
栈中分配局部变量空间，堆区是向上增长的用于分配程序员申请的内存空间。另外还有静态区是分配静态变量，全局变量空间的。只读区是分配常量和程序代码空间的；以及其他一些分区。

三 、 内存分配中栈区和堆区的区别

0、申请方式和回收方式不同
不知道你是否有点明白了，堆和栈的第一个区别就是申请方式的不同：栈（英文名字stack）是系统自动分配空间的，例如我们定义了一个 char a ；系统会自动的在栈上为其开辟空间。而堆（英文名字:heap）则是程序员根据需要自己申请的空间，例如malloc(10); 开辟是1个字节的空间。由于栈上的空间是自动分配自动回收的，所以栈上的数据的生存周期只是在函数的运行过程中，运行后就释放掉，不可以再访问。而堆上的数据只要程序员不释放空间，就一直可以访问到，不过缺点是一旦忘记释放会造成内存泄露。
1、 申请后系统的响应
栈 ： 只要栈的剩余空间大于所申请的空间，系统将为程序提供内存，否则将报异常提示栈溢出。
堆：首先应该知道操作系统有一个记录空闲内存地址的链表，当系统受到程序的申请时，会遍历该链表，寻找第一个空间大于所申请空间的堆结点，然后将该结点从空闲结点链表中删除，并将该结点的空间分配给程序，另外，对于大多数系统，会在这块内存空间中的首地址处记录本次分配的大小，这样，代码中的delete语句才能正确的释放本内存空间。另外，由于找到的堆结点的大小不一定正好等于申请的大小，系统会自动的将多余的那部分重新放入空闲链表中。也就是说堆会在申请后还要做一些后续的工作这就会引出申请效率的问题
2、申请效率的比较
栈： 由系统自动分配，速度较快。但程序员是无法控制的。
堆： 是由new分配的内存，一般速度比较慢，而且容易产生内存碎片，不过用起来最方便。

3、 申请大小的限制
栈： 在Windows下，栈是向低地址扩展的数据结构，是一块连续的内存的区域。这句话的意思是栈顶的地址和栈的最大容量是系统预先规定好的，在Windows下，栈的大小是2M（也有的说是1M，总之是一个编译时就确定的常数），如果申请的空间超过栈的剩余空间时，将提示overflow。因此，能从栈获得的空间较小。
堆：堆是向高地址扩展的数据结构，是不连续的内存区域。这是由于系统是用链表来存储空闲内存地址的，自然是不连续的，而链表的遍历方向是由低地址向高地址。堆的大小受限于计算机系统中有效的虚拟内存。由此可见，堆获得的空间比较灵活，也比较大。

4、堆和栈中的内存内容
由于栈的大小限制，所以用子函数还是有物理意义的，而不仅仅是逻辑意义。
栈：在函数调用时，第一个进栈的是主函数中函数调用后的下一条指令（函数调用语句的吓一跳可执行语句）的地址，然后是函数的各个参数，在大多数的C编译器中，参数是有右往左入栈的，然后是函数中的局部变量。注意静态变量是不入栈的。当本次函数调用结束后，局部变量先出栈，然后是参数，最后栈顶指针指向最开始存的地址，也就是主函数中的下一条指令，程序由该点继续运行。

堆：一般是在堆的头部用一个字节存放堆的大小。堆中的具体内容由程序员安排。

5、 关于堆和栈一个比较形象的比喻
栈：使用栈就像我们去饭馆里吃饭，只管点菜（发出申请）、付钱、吃（使用），吃饱了就走，不必理会切菜，洗菜等准备工作和洗碗、刷锅等扫尾工作，他的好处就是快捷，但是自由度小.
堆：使用堆就像是自己动手做喜欢的菜肴，比较麻烦，但是比较符合自己的口味，而且自由度大。
34.定义一个空类编译器做了哪些操作？
如果你只是声明一个空类，不做任何事情的话，编译器会自动为你生成一个默认构造函数、一个拷贝默认构造函数、一个默认拷贝赋值操作符和一个默认析构函数。这些函数只有在第一次被调用时，才会被编译器创建。所有这些函数都是inline和public的。

定义一个空类例如：

	class Empty
	{
	}
1
2
3

一个空的class在C++编译器处理过后就不再为空，编译器会自动地为我们声明一些member function，一般编译过就相当于：

	class Empty
	{
	public:
	Empty(); // 缺省构造函数//
	Empty( const Empty& ); // 拷贝构造函数//
	~Empty(); // 析构函数//
	Empty& operator=( const Empty& ); // 赋值运算符//
	};```
	需要注意的是，只有当你需要用到这些函数的时候，编译器才会去定义它们。
	
**35.友元函数和友元类
	**友元提供了不同类的成员函数之间、类的成员函数与一般函数之间进行数据共享的机制。通过友元，一个不同函数或另一个类中的成员函数可以访问类中的私有成员和保护成员。
	友元的正确使用能提高程序的运行效率，但同时也破坏了类的封装性和数据的隐藏性，导致程序可维护性变差。
	
	友元函数 ：
	友元函数是可以直接访问类的私有成员的非成员函数。它是定义在类外的普通函数，它不属于任何类，但需要在类的定义中加以声明，声明时只需在友元的名称前加上关键字friend，其格式如下： 

friend 类型 函数名(形式参数);
    友元函数的声明可以放在类的私有部分，也可以放在公有部分，它们是没有区别的，都说明是该类的一个友元函数。
      一个函数可以是多个类的友元函数，只需要在各个类中分别声明。
      友元函数的调用与一般函数的调用方式和原理一致。

 
友元类 ：
      友元类的所有成员函数都是另一个类的友元函数，都可以访问另一个类中的隐藏信息（包括私有成员和保护成员）。       
      当希望一个类可以存取另一个类的私有成员时，可以将该类声明为另一类的友元类。定义友元类的语句格式如下：
      friend class 类名;
      其中：friend和class是关键字，类名必须是程序中的一个已定义过的类。
      使用友元类时注意：
          (1) 友元关系不能被继承。
          (2) 友元关系是单向的，不具有交换性。若类B是类A的友元，类A不一定是类B的友元，要看在类中是否有相应的声明。
          (3) 友元关系不具有传递性。若类B是类A的友元，类C是B的友元，类C不一定是类A的友元，同样要看类中是否有相应的申明
	**
**36.什么情况下，类的析构函数应该声明为虚函数？为什么？**
	基类指针可以指向派生类的对象（多态性），如果删除该指针delete []p；就会调用该指针指向的派生类析构函数，而派生类的析构函数又自动调用基类的析构函数，这样整个派生类的对象完全被释放。

如果析构函数不被声明成虚函数，则编译器实施静态绑定，在删除基类指针时，只会调用基类的析构函数而不调用派生类析构函数，这样就会造成派生类对象析构不完全。
	也就是该类需要被继承并且之后的子类对象的释放操作需要由基类指针释放时。
**37.哪些函数不能成为虚函数？**
1）普通函数
	普通函数不属于成员函数，是不能被继承的。普通函数只能被重载，不能被重写，因此声明为虚函数没有意义。因为编译器会在编译时绑定函数。

而多态体现在运行时绑定。通常通过基类指针指向子类对象实现多态。

2）友元函数
	友元函数不属于类的成员函数，不能被继承。对于没有继承特性的函数没有虚函数的说法。
	
3）构造函数
	假如子类可以继承基类构造函数，那么子类对象的构造将使用基类的构造函数，而基类构造函数并不知道子类的有什么成员，显然是不符合语义的。从另外一个角度来讲，多态是通过基类指针指向子类对象来实现多态的，在对象构造之前并没有对象产生，因此无法使用多态特性，这是矛盾的。因此构造函数不允许继承。
	
4）内联成员函数
	我们需要知道内联函数就是为了在代码中直接展开，减少函数调用花费的代价。也就是说内联函数是在编译时展开的。而虚函数是为了实现多态，是在运行时绑定的。因此显然内联函数和多态的特性相违背。

5）静态成员函数
	首先静态成员函数理论是可继承的。但是静态成员函数是编译时确定的，无法动态绑定，不支持多态，因此不能被重写，也就不能被声明为虚函数。静态成员函数不属于类，也就谈不上继承，也就和虚函数没有关系。
**38.编写一个有构造函数，析构函数，赋值函数，和拷贝构造函数的String类

```cpp
	**class mstring {
	public:
	    mstring();
	    mstring(const char* str);
	    mstring(const mstring& other);
	    ~mstring();
	    mstring& operator= (const mstring& other);
	private:
	    char* m_data;
	    unsigned m_size;
	};
	
mstring::mstring()
{
    m_data = new char[1];
    *m_data = '\0';
    m_size = 0;
}
mstring::mstring(const char* str)
{
    if (str == NULL)
    {
        m_data = new char[1];
        *m_data = '\0';
        m_size = 0;
    }
    else
    {
        unsigned m_size = static_cast<unsigned int>(strlen(str));
        m_data = new char[static_cast<size_t>(m_size) + 1];
        strcpy(m_data, str);
    }
}
mstring::mstring(const mstring& other)
{
    m_data = new char[(size_t)other.m_size + 1];
    strcpy(m_data, other.m_data);
    m_size = other.m_size;
}
mstring::~mstring()
{
    if (m_data != NULL)
    {
        delete []m_data;
        m_data = NULL;
        m_size = 0;
    } 
}
mstring& mstring::operator= (const mstring& other)
{
    if (this == &other)
        return *this;
    if (m_data != NULL)
        delete[] m_data;
    m_size = other.m_size;
    m_data = new char[m_size + 1];
    strcpy(m_data, other.m_data);
    return *this;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117

39.this指针的理解
先要理解class的意思。class应该理解为一种类型，象int,char一样，是用户自定义的类型。用这个类型可以来声明一个变量，比如int x, myclass my等等。这样就像变量x具有int类型一样，变量my具有myclass类型。理解了这个，就好解释this了，my里的this 就是指向my的指针。如果还有一个变量myclass mz，mz的this就是指向mz的指针。 这样就很容易理解this 的类型应该是myclass ,而对其的解引用this就应该是一个myclass类型的变量。
通常在class定义时要用到类型变量自身时，因为这时候还不知道变量名（为了通用也不可能固定实际的变量名），就用this这样的指针来使用变量自身。
1. this指针的用处:
一个对象的this指针并不是对象本身的一部分，不会影响sizeof(对象)的结果。this作用域是在类内部，当在类的非静态成员函数中访问类的非静态成员的时候，编译器会自动将对象本身的地址作为一个隐含参数传递给函数。也就是说，即使你没有写上this指针，编译器在编译的时候也是加上this的，它作为非静态成员函数的隐含形参，对各成员的访问均通过this进行。例如，调用date.SetMonth(9) <===> SetMonth(&date, 9)，this帮助完成了这一转换 .
在成员函数内部，我们可以直接使用调用该函数的对象的成员，而无需通过成员访问运算符来做到这一点，因为this所指的正是这个对象。任何对类成员的直接访问都被看成this的隐式使用。
this的目的总是指向这个对象，所以this是一个常量指针，我们不允许改变this中保存的地址。
2. this指针的使用:
一种情况就是，在类的非静态成员函数中返回类对象本身的时候，直接使用 return *this；另外一种情况是当参数与成员变量名相同时，如this->n = n （不能写成n = n）。
40.程序加载时的内存分布
在多任务操作系统中，每个进程都运行在一个属于自己的虚拟内存中，而虚拟内存被分为许多页，并映射到物理内存中，被加载到物理内存中的文件才能够被执行。这里我们主要关注程序被装载后的内存布局，其可执行文件包含了代码段，数据段，BSS段，堆，栈等部分，其分布如下图所示。

**代码段(.text)：**用来存放可执行文件的机器指令。存放在只读区域，以防止被修改。
**只读数据段(.rodata)：**用来存放常量存放在只读区域，如字符串常量、全局const变量等。
**可读写数据段(.data)：**用来存放可执行文件中已初始化全局变量，即静态分配的变量和全局变量。
**BSS段(.bss)：**未初始化的全局变量和局部静态变量以及初始化为0的全局变量一般放在.bss的段里，以节省内存空间。eg:static int a=0;(初始化为0的全局变量（静态变量）放在.bss)。
**堆：**用来容纳应用程序动态分配的内存区域。当程序使用malloc或new分配内存时，得到的内存来自堆。堆通常位于栈的下方。
**栈：**用于维护函数调用的上下文。栈通常分配在用户空间的最高地址处分配。
**动态链接库映射区：**如果程序调用了动态链接库，则会有这一部分。该区域是用于映射装载的动态链接库。
**保留区：**内存中受到保护而禁止访问的内存区域。

41.智能指针
智能指针是在 头文件中的std命名空间中定义的，该指针用于确保程序不存在内存和资源泄漏且是异常安全的。它们对RAII“获取资源即初始化”编程至关重要，RAII的主要原则是为将任何堆分配资源（如动态分配内存或系统对象句柄）的所有权提供给其析构函数包含用于删除或释放资源的代码以及任何相关清理代码的堆栈分配对象。大多数情况下，当初始化原始指针或资源句柄以指向实际资源时，会立即将指针传递给智能指针。
智能指针的设计思想：将基本类型指针封装为类对象指针（这个类肯定是个模板，以适应不同基本类型的需求），并在析构函数里编写delete语句删除指针指向的内存空间。
unique_ptr只允许基础指针拥有一个所有者。unique_ptr小巧高效；大小等同于一个指针且支持右值引用，从而可实现快速插入和对STL集合的检索。
shared_ptr采用引用计数的智能指针，主要用于要将一个原始指针分配给多个所有者（例如，从容器返回了指针副本又想保留原始指针时）的情况。当所有的shared_ptr所有者超出了范围或放弃所有权，才会删除原始指针。大小为两个指针；一个用于对象，另一个用于包含引用计数的共享控制块。最安全的分配和使用动态内存的方法是调用make_shared标准库函数，此函数在动态分配内存中分配一个对象并初始化它，返回对象的shared_ptr。

注：1.引用计数问题
每个shared_ptr所指向的对象都有一个引用计数，它记录了有多少个shared_ptr指向自己，shared_ptr的析构函数：递减它所指向的对象的引用计数，如果引用计数变为0，就会销毁对象并释放相应的内存，引用计数的变化，决定权在shared_ptr，而与对象本身无关。

智能指针支持的操作
使用重载的->和*运算符访问对象。
使用get成员函数获取原始指针，提供对原始指针的直接访问。你可以使用智能指针管理你自己的代码中的内存，还能将原始指针传递给不支持智能指针的代码。
使用删除器定义自己的释放操作。
使用release成员函数的作用是放弃智能指针对指针的控制权，将智能指针置空，并返回原始指针。（只支持unique_ptr）
使用reset释放智能指针对对象的所有权。

	#include <iostream>
	#include <string>
	#include <memory>
	using namespace std;
	
	class base
	{
	public:
	    base(int _a): a(_a)    {cout<<"构造函数"<<endl;}
	    ~base()    {cout<<"析构函数"<<endl;}
	    int a;
	};
		int main()
	{
	    unique_ptr<base> up1(new base(2));
	    // unique_ptr<base> up2 = up1;   //编译器提示未定义
	    unique_ptr<base> up2 = move(up1);  //转移对象的所有权 
	    // cout<<up1->a<<endl; //运行时错误 
	    cout<<up2->a<<endl; //通过解引用运算符获取封装的原始指针 
	    up2.reset(); // 显式释放内存 
	
	    shared_ptr<base> sp1(new base(3));
	    shared_ptr<base> sp2 = sp1;  //增加引用计数 
	    cout<<"共享智能指针的数量："<<sp2.use_count()<<endl;  //2
	    sp1.reset();  //
	    cout<<"共享智能指针的数量："<<sp2.use_count()<<endl;  //1
	    cout<<sp2->a<<endl; 
	    auto sp3 = make_shared<base>(4);//利用make_shared函数动态分配内存 
	}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

3.智能指针的陷阱（循环引用等问题）

class B;
		class A
		{
		public:
		　　shared_ptr<B> m_b;
		};
		class B
		{
		public:
		　　shared_ptr<A> m_a;
		};
	
		int main()
		{
		　　{
		　　　　shared_ptr<A> a(new A);  //new出来的A的引用计数此时为1
		　　　　shared_ptr<B> b(new B);  //new出来的B的引用计数此时为1
		　　　　a->m_b = b;              //B的引用计数增加为2
		　　　　b->m_a = a;              //A的引用计数增加为2
		　　}
		　　//b先出作用域，B的引用计数减少为1，不为0；
		　　//所以堆上的B空间没有被释放，且B持有的A也没有机会被析构，A的引用计数也完全没减少
		
		　　//a后出作用域，同理A的引用计数减少为1，不为0，所以堆上A的空间也没有被释放
		}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

循环引用”简单来说就是：两个对象互相使用一个shared_ptr成员变量指向对方会造成循环引用。
即A内部有指向B，B内部有指向A，这样对于A，B必定是在A析构后B才析构，对于B，A必定是在B析构后才析构A，这就是循环引用问题，违反常规，导致内存泄露。
解决循环引用方法：

1. 当只剩下最后一个引用的时候需要手动打破循环引用释放对象。
2. 当A的生存期超过B的生存期的时候，B改为使用一个普通指针指向A。
3. 使用weak_ptr打破这种循环引用，因为weak_ptr不会修改计数器的大小，所以就不会产生两个对象互相使用一个shared_ptr成员变量指向对方的问题，从而不会引起引用循环。

42.vector扩容原理说明
新增元素：Vector通过一个连续的数组存放元素，如果集合已满，在新增数据的时候，就要分配一块更大的内存，将原来的数据复制过来，释放之前的内存，在插入新增的元素；
对vector的任何操作，一旦引起空间重新配置，指向原vector的所有迭代器就都失效了 ；
初始时刻vector的capacity为0，塞入第一个元素后capacity增加为1；
不同的编译器实现的扩容方式不一样，VS2015中以1.5倍扩容，GCC以2倍扩容。
vector在push_back以成倍增长可以在均摊后达到O(1)的事件复杂度，相对于增长指定大小的O(n)时间复杂度更好。
为了防止申请内存的浪费，现在使用较多的有2倍与1.5倍的增长方式，而1.5倍的增长方式可以更好的实现对内存的重复利用，因为更好。

43.内联函数和宏定义的区别
1.宏定义不是函数，但是使用起来像函数。预处理器用复制宏代码的方式代替函数的调用，省去了函数压栈退栈过程，提高了效率。
内联函数本质上是一个函数，内联函数一般用于函数体的代码比较简单的函数，不能包含复杂的控制语句，while、switch，并且内联函数本身不能直接调用自身。如果内联函数的函数体过大，编译器会自动 的把这个内联函数变成普通函数。
2. 宏定义是在预处理的时候把所有的宏名用宏体来替换，简单的说就是字符串替换
内联函数则是在编译的时候进行代码插入，编译器会在每处调用内联函数的地方直接把内联函数的内容展开，这样可以省去函数的调用的开销，提高效率。
3. 宏定义是没有类型检查的，无论对还是错都是直接替换
内联函数在编译的时候会进行类型的检查，内联函数满足函数的性质，比如有返回值、参数列表等
4. 宏定义和内联函数使用的时候都是进行代码展开。不同的是宏定义是在预编译的时候把所有的宏名替换，内联函数则是在编译阶段把所有调用内联函数的地方把内联函数插入。这样可以省去函数压栈退栈，提高了效率
44.内联函数与普通函数的区别
5. 内联函数和普通函数的参数传递机制相同，但是编译器会在每处调用内联函数的地方将内联函数内容展开，这样既避免了函数调用的开销又没有宏机制的缺陷。

6. 普通函数在被调用的时候，系统首先要到函数的入口地址去执行函数体，执行完成之后再回到函数调用的地方继续执行，函数始终只有一个复制。

   内联函数不需要寻址，当执行到内联函数的时候，将此函数展开，如果程序中有N次调用了内联函数则会有N次展开函数代码。

7. 内联函数有一定的限制，内联函数体要求代码简单，不能包含复杂的结构控制语句。如果内联函数函数体过于复杂，编译器将自动把内联函数当成普通函数来执行。
   45.C++中成员函数能够同时用static和const进行修饰？
   不能。
   C++编译器在实现const的成员函数（const加在函数右边）的时候为了确保该函数不能修改类的中参数的值，会在函数中添加一个隐式的参数const this*。但当一个成员为static的时候，该函数是没有this指针的。也就是说此时const的用法和static是冲突的。
   即：static修饰的函数表示该函数是属于类的，而不是属于某一个对象的，没有this指针。const修饰的函数表示该函数不能改变this中的内容，会有一个隐含的const this指针。两者是矛盾的。
   46.溢出，越界，泄漏
   要求分配的内存超出了系统能够分配的，系统不能满足，于是产生溢出。
   （1）栈溢出
   a. 栈溢出是指函数中的局部变量造成的溢出（函数的形参和局部变量存放在栈上）栈的大小通常是1 - 2M，所以栈溢出包含两种情况，一是分配的的大小超过栈的最大值，二是分配的大小没有超过最大值，但是接收的buff比新buff小（buff：缓冲区, 它本质上就是一段存储数据的内存）。
   例子1：（分配的的大小超过栈的最大值）

	void func()
	{
	    char a[99999999999999999];
	}
1
2
3
4

例子2：（接收的buff比新buff小）

	void func()
	{
	   char a[10] = {0};
	   strcpy(a, "abjjijjlljiojohihiihiiiiiiiiiiiiiiiiiiiiiiiiii");
	}
1
2
3
4
5

注意：调试时栈溢出的异常要在函数调用结束后才会检测到，因为栈是在函数结束时才会开始进行出栈操作
如：

	int main(int argc, char* argv[])
	{
		char a[10] = {0};
		strcpy(a, "abjjijjlljiojohihiihiiiiiiiiiiiiiiiiiiiiiiiiii");
		exit(0);
		return 0;
	}
1
2
3
4
5
6
7

上面情况是检测不到栈溢出的，因为函数还没执行完就退出了

	void fun()
	{
	 char a[10] = {0};
	 strcpy(a, "abjjijjlljiojohihiihiiiiiiiiiiiiiiiiiiiiiiiiii");
	}
	int main(int argc, char* argv[])
	{
	  fun();
	  exit(0);
	  return 0;
	}
1
2
3
4
5
6
7
8
9
10
11

这种情况调用完fun函数就会检测到异常了
b.栈溢出的解决办法
如果是超过栈的大小时，那就直接换成用堆；如果是不超过栈大小但是分配值小的，就增大分配的大小。

（2）内存溢出
使用malloc和new分配的内存，在拷贝时接收buff小于新buff时造成的现象
解决：增加分配的大小

2.越界
越界通常指的是数组越界，如
char a[9]={0};
cout << a[9] << endl;

3.泄漏
这里泄漏通常是指堆内存泄漏，是指使用malloc和new分配的内存没有释放造成的。

47.C/C++中分配内存的方法

1. malloc 函数： void *malloc(unsigned int size)
   在内存的动态分配区域中分配一个长度为size的连续空间，如果分配成功，则返回所分配内存空间的首地址，否则返回NULL，申请的内存不会进行初始化。

2）calloc 函数： void *calloc(unsigned int num, unsigned int size)
按照所给的数据个数和数据类型所占字节数，分配一个 num * size 连续的空间。calloc申请内存空间后，会自动初始化内存空间为 0，但是malloc不会进行初始化，其内存空间存储的是一些随机数据。

3）realloc 函数： void *realloc(void *ptr, unsigned int size)
动态分配一个长度为size的内存空间，并把内存空间的首地址赋值给ptr，把ptr内存空间调整为size。 申请的内存空间不会进行初始化。

4）new是动态分配内存的运算符，自动计算需要分配的空间，在分配类类型的内存空间时，同时调用类的构造函数，对内存空间进行初始化，即完成类的初始化工作。动态分配内置类型是否自动初始化取决于变量定义的位置，在函数体外定义的变量都初始化为0，在函数体内定义的内置类型变量都不进行初始化。
48.构造函数初始化列表
构造函数初始化列表以一个冒号开始，接着是以逗号分隔的数据成员列表，每个数据成员后面跟一个放在括号中的初始化式。例如：

	class CExample {
	public:
	    int a;
	    float b;
	    //构造函数初始化列表
	    CExample(): a(0),b(8.8)
	    {}
	    //构造函数内部赋值
	    CExample()
	    {
	        a=0;
	        b=8.8;
	    }
	};
1
2
3
4
5
6
7
8
9
10
11
12
13
14

上面的例子中两个构造函数的结果是一样的。上面的构造函数（使用初始化列表的构造函数）显式的初始化类的成员；而没使用初始化列表的构造函数是对类的成员赋值，并没有进行显式的初始化。

初始化和赋值对内置类型的成员没有什么大的区别，像上面的任一个构造函数都可以。对非内置类型成员变量，为了避免两次构造，推荐使用类构造函数初始化列表。但有的时候必须用带有初始化列表的构造函数：
1.成员类型是没有默认构造函数的类。若没有提供显示初始化式，则编译器隐式使用成员类型的默认构造函数，若类没有默认构造函数，则编译器尝试使用默认构造函数将会失败。
2.const成员或引用类型的成员。因为const对象或引用类型只能初始化，不能对他们赋值。
初始化数据成员与对数据成员赋值的含义是什么？有什么区别？
首先把数据成员按类型分类并分情况说明:
1.内置数据类型，复合类型（指针，引用）
在成员初始化列表和构造函数体内进行，在性能和结果上都是一样的
2.用户定义类型（类类型）
结果上相同，但是性能上存在很大的差别。因为类类型的数据成员对象在进入函数体前已经构造完成（先进行了一次隐式的默认构造函数调用），也就是说在成员初始化列表处进行构造对象的工作，调用构造函数，在进入函数体之后，进行的是对已经构造好的类对象的赋值，又调用了拷贝赋值操作符才能完成（如果并未提供，则使用编译器提供的默认按成员赋值行为）。

49.vector中v[i]与v.at(i)的区别

void f(vector<int> &v)
		{
		  v[5];    // A
		  v.at[5];  // B
	}
1
2
3
4
5

如果v非空，A行和B行没有任何区别。如果v为空，B行会抛出std::out_of_range异常，A行的行为未定义。c++标准不要求vector::operator[]进行下标越界检查，原因是为了效率，总是强制下标越界检查会增加程序的性能开销。设计vector是用来代替内置数组的，所以效率问题也应该考虑。不过使用operator[]就要自己承担越界风险了。
如果需要下标越界检查，请使用at。但是请注意，这时候的性能也是响应的会受影响，因为越界检查增加了性能的开销。

50.指向函数的指针–函数指针
函数具有可赋值给指针的物理内存地址，一个函数的函数名就是一个指针，它指向函数的代码。一个函数的地址是该函数的进入点，也是调用函数的地址。函数的调用可以通过函数名，也可以通过指向函数的指针来调用。函数指针还允许将函数作为变元传递给其他函数。
不带括号和变量列表的函数名，这可以表示函数的地址，正如不带下标的数组名可以表示数组的首地址。
定义形式*：类型 （*指针变量名）（参数列表）；
例如：
int (*p)(int i,int j);
p是一个指针，它指向一个函数，该函数有2个整形参数，返回类型为int。p首先和结合，表明p是一个指针。然后再与（）结合，表明它指向的是一个函数。指向函数的指针也称为函数指针。
注意：
int f(int i, int j);
** int (p)(int i, int j);
前者是返回值是指针的函数；后者是一个指向函数的指针。

51.C++中调用C的函数

参考：https://www.cnblogs.com/shijiaqi1066/p/6349243.html

有一个程序，代码目录如下：
1

|-- calc
| |-- calc.c
| -- calc.h– main.cpp
假如main.cpp需要调用calc.h中的函数（calc.c是c代码）
传统C编程中需要#include "calc/calc.h"后，声明函数，然后调用。
但是由于main.cpp是个C++代码。以C方式的调用，g++编译器无法通过编译。

解决方案一：
若calc中代码量很小，或代码是自己写的可以直接利用c++兼容c的特性，把calc.c改成calc.cpp。即可编译。

解决方案二：
在calc.h中的每个函数最前面添加：extern “C”
比较简单的方案是：

	extern "C" { 
	    void fun1(int arg1); 
	    void fun2(int arg1, int arg2); 
	    void fun3(int arg1, int arg2, int arg3); 
	}
1
2
3
4
5

若不确定当前编译环境是C还是C++，可以这样：

	#ifdef __cplusplus 
	extern "C" {
	#endif
	
	void fun1(int arg1); 
	void fun2(int arg1, int arg2); 
	void fun3(int arg1, int arg2, int arg3);
	
	#ifdef __cplusplus 
	}
	#endif
1
2
3
4
5
6
7
8
9
10
11

解决方法三：
若别人已经写好的头文件，我们无法修改，怎么办？重写一个专门被c++用的头文件即可。

例：编写头文件 cpp_calc.h

	extern "C" {
	#include "calc.h"; 
	}
1
2
3

52.指针常量与常量指针
常量指针(被指向的对象是常量)
定义：又叫常指针，可以理解为常量的指针，指向的是个常量

常量指针指向的对象不能通过这个指针来修改，可是仍然可以通过原来的声明修改；
常量指针可以被赋值为变量的地址，之所以叫常量指针，是限制了通过这个指针修改变量的值；
指针还可以指向别处，因为指针本身只是个变量，可以指向任意地址；

const int *p或int const *p
1

指针常量(指针本身是常量)

定义：本质是一个常量，而用指针修饰它。指针常量的值是指针，这个值因为是常量，所以不能被赋值。

它是个常量！
指针所保存的地址不改变，然而指针所指向的值却可以改变；
指针本身是常量，指向的地址不可以变化,但是指向的地址所对应的内容可以变化；

int* const p;
1

53.防止头文件被重复包含
参考：https://blog.csdn.net/shufac/article/details/24334601
方式一：

#ifndef SOMEFILE_H

#define SOMEFILE_H

… // 一些声明语句

#endif

方式二：

#pragma once

… … // 一些声明语句

3. 两者比较

l #ifndef的方式依赖于宏名字不能冲突，这不光可以保证同一个文件不会被包含多次，也能保证内容完全相同的两个文件不会被不小心同时包含。当然，缺点就是如果不同头文件的宏名不小心“撞车”，可能就会导致头文件明明存在，编译器却硬说找不到声明的状况。

l #pragma once则由编译器提供保证：同一个文件不会被编译多次。注意这里所说的“同一个文件”是指物理上的一个文件，而不是指内容相同的两个文件。带来的好处是，你不必再费劲想个宏名了，当然也就不会出现宏名碰撞引发的奇怪问题。对应的缺点就是如果某个头文件有多份拷贝，本方法不能保证他们不被重复包含。当然，相比宏名碰撞引发的“找不到声明”的问题，重复包含更容易被发现并修正。

l 方式一由语言支持所以移植性好，方式二 可以避免名字冲突

l #pragma once方式产生于#ifndef之后，因此很多人可能甚至没有听说过。目前看来#ifndef更受到推崇。因为#ifndef受语言天生的支持，不受编译器的任何限制；而#pragma once方式却不受一些较老版本的编译器支持，换言之，它的兼容性不够好。也许，再过几年等旧的编译器死绝了，这就不是什么问题了。

我还看到一种用法是把两者放在一起的：

#pragma once

#ifndef SOMEFILE_H

#define SOMEFILE_H

… … // 一些声明语句

#endif

看起来似乎是想兼有两者的优点。不过只要使用了#ifndef就会有宏名冲突的危险，所以混用两种方法似乎不能带来更多的好处，倒是会让一些不熟悉的人感到困惑。

二、头文件重复包含的影响

重复包含头文件有以下问题：

1. 使预处理的速度变慢了，要处理很多本来不需要处理的头文件。

2. 可能预处理器就陷入死循环了（其实编译器都会规定一个包含层数的上限）。例如C.h包含D.h，D.h又包含C.h的情况，如果不采用防止头文件的重复定义，那么预处理器就会进入死循环了。

3. 头文件里有些代码不允许重复出现。而重复定义头文件会重复出现一些代码。（虽然变量和函数允许多次声明（只要不是多次定义就行），但头文件里有些代码是不允许多次出现的）。例如：使用typedef类型定义和结构体Tag定义等，在一个程序文件中只允许出现一次。

54.详解拷贝构造函数相关知识
参考：https://www.cnblogs.com/alantu2018/p/8459250.html
一、什么是拷贝构造函数
首先对于普通类型的对象来说，它们之间的复制是很简单的，例如：

	int a=100;
	int b=a;
1
2

而类对象与普通对象不同，类对象内部结构一般较为复杂，存在各种成员变量。 下面看一个类对象拷贝的简单例子。

	#include<iostream>
	using namespace std;
	class CExample
	{
	private:
	    int a;
	public:
	    //构造函数
	    CExample(int b)
	    {
	        a=b;
	        printf("constructor is called\n");
	    }
	    //拷贝构造函数
	    CExample(const CExample & c)
	    {
	        a=c.a;
	        printf("copy constructor is called\n");
	    }
	    //析构函数
	    ~CExample()
	    {
	        cout<<"destructor is called\n";
	    }
	    void Show()
	    {
	        cout<<a<<endl;
	    }
	};
	int main()
	{
	    CExample A(100);
	    CExample B=A;
	    B.Show(); 
	    return 0;
	}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36

运行程序，屏幕输出100。从以上代码的运行结果可以看出，系统为对象 B 分配了内存并完成了与对象 A 的复制过程。就类对象而言，相同类型的类对象是通过拷贝构造函数来完成整个复制过程的。
CExample(const CExample& C)　就是我们自定义的拷贝构造函数。可见，拷贝构造函数是一种特殊的构造函数，函数的名称必须和类名称一致，它必须的一个参数是本类型的一个引用变量。

二、拷贝构造函数的调用时机
1. 当函数的参数为类的对象时

	#include<iostream>
	using namespace std;
	class CExample
	{
	private:
	    int a;
	public:
	    CExample(int b)
	    {
	        a=b;
	        printf("constructor is called\n");
	    }
	    CExample(const CExample & c)
	    {
	        a=c.a;
	        printf("copy constructor is called\n");
	    }
	    ~CExample()
	    {
	     cout<<"destructor is called\n";
	    }
	    void Show()
	    {
	     cout<<a<<endl;
	    }
	};
	void g_fun(CExample c)
	{
	    cout<<"g_func"<<endl;
	}
	int main()
	{
	    CExample A(100);
	    CExample B=A;
	    B.Show(); 
	    g_fun(A);
	    return 0;
	}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38

调用g_fun()时，会产生以下几个重要步骤：
(1).A对象传入形参时，会先会产生一个临时变量，就叫 C 吧。
(2).然后调用拷贝构造函数把A的值给C。 整个这两个步骤有点像：CExample C(A);
(3).等g_fun()执行完后, 析构掉 C 对象。

2. 函数的返回值是类的对象

	#include<iostream>
	using namespace std;
	class CExample
	{
	private:
	    int a;
	public:
	    //构造函数
	    CExample(int b)
	    {
	     a=b;
	        printf("constructor is called\n");
	    }
	    //拷贝构造函数
	    CExample(const CExample & c)
	    {
	     a=c.a;
	        printf("copy constructor is called\n");
	    }
	    //析构函数
	    ~CExample()
	    {
	     cout<<"destructor is called\n";
	    }
	    void Show()
	    {
	     cout<<a<<endl;
	    }
	};
	CExample g_fun()
	{
	    CExample temp(0);
	    return temp;
	}
	int main()
	{
	    
	    g_fun();
	    return 0;
	}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40

当g_Fun()函数执行到return时，会产生以下几个重要步骤：
(1). 先会产生一个临时变量，就叫X吧。
(2). 然后调用拷贝构造函数把temp的值给X。整个这两个步骤有点像：CExample X(temp);
(3). 在函数执行到最后先析构temp局部变量。
(4). 等g_fun()执行完后再析构掉X对象。
3. 对象需要通过另外一个对象进行初始化

	CExample A(100);
	CExample B=A;
1
2

三、浅拷贝与深拷贝
1. 默认拷贝构造函数
很多时候在我们都不知道拷贝构造函数的情况下，传递对象给函数参数或者函数返回对象都能很好的进行，这是因为编译器会给我们自动产生一个拷贝构造函数，这就是“默认拷贝构造函数”，这个构造函数很简单，仅仅使用“老对象”的数据成员的值对“新对象”的数据成员一一进行赋值，它一般具有以下形式：

	Rect::Rect(const Rect& r)
	{
	    width=r.width;
	    height=r.height;
	}
1
2
3
4
5

当然，以上代码不用我们编写，编译器会为我们自动生成。但是如果认为这样就可以解决对象的复制问题，那就错了，让我们来考虑以下一段代码：

	#include<iostream>
	using namespace std;
	class Rect
	{
	public:
	    Rect()
	    {
	     count++;
	    }
	    ~Rect()
	    {
	     count--;
	    }
	    static int getCount()
	    {
	     return count;
	    }
	private:
	    int width;
	    int height;
	    static int count;
	};
	int Rect::count=0;
	int main()
	{
	    Rect rect1;
	    cout<<"The count of Rect:"<<Rect::getCount()<<endl;
	    Rect rect2(rect1);
	    cout<<"The count of Rect:"<<Rect::getCount()<<endl;
	    return 0;
	}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

这段代码对前面的类，加入了一个静态成员，目的是进行计数。在主函数中，首先创建对象rect1，输出此时的对象个数，然后使用rect1复制出对象rect2，再输出此时的对象个数，按照理解，此时应该有两个对象存在，但实际程序运行时，输出的都是1，反应出只有1个对象。此外，在销毁对象时，由于会调用销毁两个对象，类的析构函数会调用两次，此时的计数器将变为负数。

说白了，就是拷贝构造函数没有处理静态数据成员。

出现这些问题最根本就在于在复制对象时，计数器没有递增，我们重新编写拷贝构造函数，如下：

	#include<iostream>
	using namespace std;
	class Rect
	{
	public:
	    Rect()
	    {
	        count++;
	    }
	    Rect(const Rect& r)
	    {
	        width=r.width;
	        height=r.height;
	        count++;
	    }
	    ~Rect()
	    {
	        count--;
	    }
	    static int getCount()
	    {
	        return count;
	    }
	private:
	    int width;
	    int height;
	    static int count;
	};
	int Rect::count=0;
	int main()
	{
	    Rect rect1;
	    cout<<"The count of Rect:"<<Rect::getCount()<<endl;
	    Rect rect2(rect1);
	    cout<<"The count of Rect:"<<Rect::getCount()<<endl;
	    return 0;
	}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37

2. 浅拷贝
所谓浅拷贝，指的是在对象复制时，只对对象中的数据成员进行简单的赋值，默认拷贝构造函数执行的也是浅拷贝。大多情况下“浅拷贝”已经能很好地工作了，但是一旦对象存在了动态成员，那么浅拷贝就会出问题了，让我们考虑如下一段代码：

	#include<iostream>
	#include<assert.h>
	using namespace std;
	class Rect
	{
	public:
	    Rect()
	    {
	     p=new int(100);
	    }
	   
	    ~Rect()
	    {
	     assert(p!=NULL);
	        delete p;
	    }
	private:
	    int width;
	    int height;
	    int *p;
	};
	int main()
	{
	    Rect rect1;
	    Rect rect2(rect1);
	    return 0;
	}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

在这段代码运行结束之前，会出现一个运行错误。原因就在于在进行对象复制时，对于动态分配的内容没有进行正确的操作。我们来分析一下：
在运行定义rect1对象后，由于在构造函数中有一个动态分配的语句，在使用rect1复制rect2时，由于执行的是浅拷贝，只是将成员的值进行赋值，这时 rect1.p = rect2.p，也即这两个指针指向了堆里的同一个空间，当然，这不是我们所期望的结果，在销毁对象时，两个对象的析构函数将对同一个内存空间释放两次，这就是错误出现的原因。我们需要的不是两个p有相同的值，而是两个p指向的空间有相同的值，解决办法就是使用“深拷贝”。
3. 深拷贝
在“深拷贝”的情况下，对于对象中动态成员，就不能仅仅简单地赋值了，而应该重新动态分配空间，如上面的例子就应该按照如下的方式进行处理：

	#include<iostream>
	#include<assert.h>
	using namespace std;
	class Rect
	{
	public:
	    Rect()
	    {
	     p=new int(100);
	    }
	    
	    Rect(const Rect& r)
	    {
	     width=r.width;
	        height=r.height;
	     p=new int(100);
	        *p=*(r.p);
	    }
	     
	    ~Rect()
	    {
	     assert(p!=NULL);
	        delete p;
	    }
	private:
	    int width;
	    int height;
	    int *p;
	};
	int main()
	{
	    Rect rect1;
	    Rect rect2(rect1);
	    return 0;
	}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35

此时，在完成对象的复制后，此时rect1的p和rect2的p各自指向一段内存空间，但它们指向的空间具有相同的内容，这就是所谓的“深拷贝”。

3. 防止默认拷贝发生
通过对对象复制的分析，我们发现对象的复制大多在进行“值传递”时发生，这里有一个小技巧可以防止按值传递——声明一个私有拷贝构造函数。甚至不必去定义这个拷贝构造函数，这样因为拷贝构造函数是私有的，如果用户试图按值传递或函数返回该类对象，将得到一个编译错误，从而可以避免按值传递或返回对象。

	//防止按值传递
	class CExample 
	{ 
	private: 
	    int a; 
	  
	public: 
	    //构造函数
	    CExample(int b) 
	    { 
	        a = b; 
	        cout<<"creat: "<<a<<endl; 
	    } 
	  
	private: 
	    //拷贝构造函数，只是声明
	    CExample(const CExample& C); 
	  
	public: 
	    ~CExample() 
	    { 
	        cout<< "delete: "<<a<<endl; 
	    } 
	  
	    void Show () 
	    { 
	        cout<<a<<endl; 
	    } 
	}; 
	  
	//???? 
	void g_Fun(CExample C) 
	{ 
	    cout<<"test"<<endl; 
	} 
	  
	int main() 
	{ 
	    CExample test(1); 
	    //g_Fun(test);   //按值传递将出错
	      
	    return 0; 
	}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43

小结：
拷贝有两种：深拷贝，浅拷贝。
当出现类的等号赋值时，会调用拷贝函数，在未定义显示拷贝构造函数的情况下，系统会调用默认的拷贝函数——即浅拷贝，它能够完成成员的一一复制。当数据成员中没有指针时，浅拷贝是可行的。但当数据成员中有指针时，如果采用简单的浅拷贝，则两类中的两个指针将指向同一个地址，当对象快结束时，会调用两次析构函数，而导致指针悬挂现象。所以，这时，必须采用深拷贝。
深拷贝与浅拷贝的区别就在于深拷贝会在堆内存中另外申请空间来储存数据，从而也就解决了指针悬挂的问题。简而言之，当数据成员中有指针时，必须要用深拷贝。

四、拷贝构造函数的几个细节
1.为什么拷贝构造函数必须是引用传递，不能是值传递？
简单的回答是为了防止递归引用。
具体一些可以这么讲：
当 一个对象需要以值方式传递时，编译器会生成代码调用它的拷贝构造函数以生成一个复本。如果类A的拷贝构造函数是以值方式传递一个类A对象作为参数的话，当 需要调用类A的拷贝构造函数时，需要以值方式传进一个A的对象作为实参； 而以值方式传递需要调用类A的拷贝构造函数；结果就是调用类A的拷贝构造函数导 致又一次调用类A的拷贝构造函数，这就是一个无限递归。
2. 拷贝构造函数的作用。
作用就是用来复制对象的，在使用这个对象的实例来初始化这个对象的一个新的实例。
3.参数传递过程到底发生了什么？
将地址传递和值传递统一起来，归根结底还是传递的是"值"(地址也是值，只不过通过它可以找到另一个值)！
i)值传递:
对于内置数据类型的传递时，直接赋值拷贝给形参(注意形参是函数内局部变量)；
对于类类型的传递时，需要首先调用该类的拷贝构造函数来初始化形参(局部对象)；如void foo(class_type obj_local){}, 如果调用foo(obj); 首先class_type obj_local(obj) ,这样就定义了局部变量obj_local供函数内部使用
ii)引用传递:
无论对内置类型还是类类型，传递引用或指针最终都是传递的地址值！而地址总是指针类型(属于简单类型), 显然参数传递时，按简单类型的赋值拷贝，而不会有拷贝构造函数的调用(对于类类型).
4. 在类中有指针数据成员时，拷贝构造函数的使用？
如果不显式声明拷贝构造函数的时候，编译器也会生成一个默认的拷贝构造函数，而且在一般的情况下运行的也很好。但是在遇到类有指针数据成员时就出现问题 了：因为默认的拷贝构造函数是按成员拷贝构造，这导致了两个不同的指针(如ptr1=ptr2)指向了相同的内存。当一个实例销毁时，调用析构函数 free(ptr1)释放了这段内存，那么剩下的一个实例的指针ptr2就无效了，在被销毁的时候free(ptr2)就会出现错误了, 这相当于重复释放一块内存两次。这种情况必须显式声明并实现自己的拷贝构造函数，来为新的实例的指针分配新的内存。

问题1和2回答了为什么拷贝构造函数使用值传递会产生无限递归调用的问题；
问题3回答了回答了在类中有指针数据成员时，拷贝构造函数使用值传递等于使用了默认的拷贝构造函数。
5. 拷贝构造函数里能调用private成员变量吗?
其时从名子我们就知道拷贝构造函数其时就是一个特殊的构造函数，操作的还是自己类的成员变量，所以不受private的限制。
6. 以下函数哪个是拷贝构造函数,为什么?

	X::X(const X&);   //拷贝构造函数
	X::X(X); 
	X::X(X&, int a=1);   //拷贝构造函数
	X::X(X&, int a=1, int b=2);  //拷贝构造函数
	```
解答：对于一个类X, 如果一个构造函数的第一个参数是下列之一:
   a) X&
   b) const X&
   c) volatile X&
   d) const volatile X&
   且没有其他参数或其他参数都有默认值,那么这个函数是拷贝构造函数.
   7. 一个类中可以存在多于一个的拷贝构造函数吗?
   解答：类中可以存在超过一个拷贝构造函数。
   
```cpp
	class X { 
	public: 
	  X(const X&); // const 的拷贝构造 
	  X(X&); // 非const的拷贝构造 
	};
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

注意,如果一个类中只存在一个参数为 X& 的拷贝构造函数,那么就不能使用const X或volatile X的对象实行拷贝初始化.
如果一个类中没有定义拷贝构造函数,那么编译器会自动产生一个默认的拷贝构造函数。
这个默认的参数可能为 X::X(const X&)或 X::X(X&),由编译器根据上下文决定选择哪一个。

五、C++构造函数以及析构函数的若干面试问题
Q1：构造函数能否重载，析构函数能否重载，为什么？
A1：构造函数可以，析构函数不可以。

Q2：析构函数为什么一般情况下要声明为虚函数？
A2：虚函数是实现多态的基础，当我们通过基类的指针是析构子类对象时候，如果不定义成虚函数，那只调用基类的析构函数，子类的析构函数将不会被调用。如 果定义为虚函数，则子类父类的析构函数都会被调用。
Q3：什么情况下必须定义拷贝构造函数？
A3：当类的对象用于函数值传递时（值参数，返回类对象），拷贝构造函数会被调用。如果对象复制并非简单的值拷贝，那就必须定义拷贝构造函数。例如大的堆 栈数据拷贝。如果定义了拷贝构造函数，那也应该重载赋值操作符。