父进程退出了，子进程会咋样

若父进程退出，子进程尚未结束，则子进程会被init进程领养，也就是说init进程将成为该子进程的父进程。

子进程继承了父进程的什么

共同点：

用户号UIDs和用户组号GIDs

环境Environment

堆栈

共享内存

打开文件的描述符

执行时关闭（Close-on-exec）

标志

信号（Signal）

控制设定

进程组号

当前工作目录

根目录

文件方式创建屏蔽字

资源限制

控制终端

子进程独有

进程号PID

不同的父进程号

自己的文件描述符和目录流的拷贝

子进程不继承父进程的进程正文（text），数据和其他锁定内存（memory locks） 不继承异步输入和输出

父进程和子进程拥有独立的地址空间和PID参数。

nohup

& ： 指在后台运行

nohup ： nohup运行命令可以使命令永久的执行下去，和用户终端没有关系，例如我们断开SSH连接都不会影响他的运行，注意了nohup没有后台运行的意思；&才是后台运行

&是指在后台运行，但当用户推出(挂起)的时候，命令自动也跟着退出

进程间的通信方式有哪些，线程间的通信方式有哪些，它们之间有哪些区别。

进程和线程的区别：

对于进程来说，子进程是父进程的复制品，从父进程那里获得父进程的数据空间，堆和栈的复制品。

 而线程，相对于进程而言，是一个更加接近于执行体的概念，可以和同进程的其他线程之间直接共享数据，而且拥有自己的栈空间，拥有独立序列。

 共同点： 它们都能提高程序的并发度，提高程序运行效率和响应时间。线程和进程在使用上各有优缺点。 线程执行开销比较小，但不利于资源的管理和保护，而进程相反。同时，线程适合在SMP机器上运行，而进程可以跨机器迁移。

 他们之间根本区别在于 多进程中每个进程有自己的地址空间，线程则共享地址空间。所有其他区别都是因为这个区别产生的。比如说：

1. 速度。线程产生的速度快，通讯快，切换快，因为他们处于同一地址空间。

2. 线程的资源利用率好。

3. 线程使用公共变量或者内存的时候需要同步机制，但进程不用。

 而他们通信方式的差异也仍然是由于这个根本原因造成的。

通信方式之间的差异

因为那个根本原因，实际上只有进程间需要通信,同一进程的线程共享地址空间,没有通信的必要，但要做好同步/互斥,保护共享的全局变量。

而进程间通信无论是信号，管道pipe还是共享内存都是由操作系统保证的，是系统调用.

一、进程间的通信方式

管道( pipe )：

管道是一种半双工的通信方式，数据只能单向流动，而且只能在具有亲缘关系的进程间使用。进程的亲缘关系通常是指父子进程关系。

有名管道 (namedpipe) ：

有名管道也是半双工的通信方式，但是它允许无亲缘关系进程间的通信。

信号量(semophore ) ：

信号量是一个计数器，可以用来控制多个进程对共享资源的访问。它常作为一种锁机制，防止某进程正在访问共享资源时，其他进程也访问该资源。因此，主要作为进程间以及同一进程内不同线程之间的同步手段。

消息队列( messagequeue ) ：

消息队列是由消息的链表，存放在内核中并由消息队列标识符标识。消息队列克服了信号传递信息少、管道只能承载无格式字节流以及缓冲区大小受限等缺点。

信号 (sinal ) ：

信号是一种比较复杂的通信方式，用于通知接收进程某个事件已经发生。

共享内存(shared memory ) ：

共享内存就是映射一段能被其他进程所访问的内存，这段共享内存由一个进程创建，但多个进程都可以访问。共享内存是最快的 IPC 方式，它是针对其他进程间通信方式运行效率低而专门设计的。它往往与其他通信机制，如信号两，配合使用，来实现进程间的同步和通信。

套接字(socket ) ：

套接口也是一种进程间通信机制，与其他通信机制不同的是，它可用于不同设备及其间的进程通信。

二、线程间的通信方式

锁机制：包括互斥锁、条件变量、读写锁

互斥锁提供了以排他方式防止数据结构被并发修改的方法。

读写锁允许多个线程同时读共享数据，而对写操作是互斥的。

条件变量可以以原子的方式阻塞进程，直到某个特定条件为真为止。对条件的测试是在互斥锁的保护下进行的。条件变量始终与互斥锁一起使用。

信号量机制(Semaphore)：包括无名线程信号量和命名线程信号量

信号机制(Signal)：类似进程间的信号处理

线程间的通信目的主要是用于线程同步，所以线程没有像进程通信中的用于数据交换的通信机制

new 和 malloc，new出来的对象用free释放会发生什么情况

new()函数实际过程中做了两步操作，第一步是分配内存空间，第二步是调用类的构造函数；delete()也同样是两步，第一步是调用类的析构函数，第二步才是释放内存；而malloc()和free()仅仅是分配内存与释放内存操作；
那么如果通过new分配的内存，再用free去释放，就会少一步调用析构函数的过程。

const用法

const的用法和注意事项：

①：被const修饰的变量可以阻止这个变量被改变，被const修饰的变量要进行初始化。

②：可以指定const指针也可以将指针指向的变量指定为const；

③：被const关键字修饰的形参的值在函数内部不能被改变；

④：const修饰的成员函数不能修改任何的成员变量（mutable修饰的变量除外）；const成员函数不能调用非const成员函数，因为非const成员函数可能会修改成员变量。

⑤：const可以修饰函数返回值，使之不能被改变。

 define和const的区别

①：const定义的常数是变量，也带类型，#define定义的只是个常数，不带类型。

②：define在预处理阶段进行替换；const在编译时确定其值；

③：define只进行简单的字符串替换，没有类型检查；而const由对应的数据类型，编译时会进行类型检查。

④：define定义的变量在预处理后存放在代码段的空间里，const修饰的变量占用数据段空间。

⑤：宏定义的作用范围仅限于当前文件，const对象使用extern声明后可以在多个文件之间共享。

 const成员函数和非const成员函数的区别

①：const和非const函数是可以构成重载的，但是仅凭返回值是否为const是无法构成重载的。

class a
{
public:
int x()
{......}
int x() const
{......}
};

这样的 const 重载是允许的 但是什么时候会调用 x()
什么时候会调用 x() const ? 他们又有什么不同呢?

 const a a1;

a a2;
a1.x();
a2.x();
a1调用const版本，a2调用非const版本

②：若将成员函数声明为const，则该函数不允许修改类的数据成员。值得注意的是，把一个成员函数声明为const可以保证这个成员函数不修改数据成员，但是，如果据成员是指针，则const成员函数并不能保证不修改指针指向的对象，编译器不会把这种修改检测为错误。

③：const成员函数可以被具有相同参数列表的非const成员函数重载。

④：const成员函数可以访问非const对象的非const数据成员、const数据成员，也可以访问const对象内的所有数据成员，但不能修改任何变量；非const成员函数可以访问非const对象的数据成员、const数据成员，但不可以访问const对象的任意数据成员。

⑤：const成员函数只能用于非静态成员函数，不能用于静态成员函数。

 C++  const和static类中使用要注意的

①：static数据成员的初始化必须在类外初始化；const数据成员必须在构造函数初始化列表中进行初始化，因为类成员不能声明初始化，同时const成员不能在成员函数中赋值，因为const不能被改变。

②：const成员函数不能改变任何一个数据成员的值，但是可以改变static成员的值

5个进程如何互斥按序访问数据

用一个数表示5个进程的访问顺序。通过条件变量来控制，当4个进程被唤醒时分别判断当前数的值，满足条件的运行，其他的阻塞。

 vector增长模式机制

如果是成倍增长：

设每次增加m倍空间

则第一次m个，第二次扩容后有m^2个，第三次有m^3个......则m^(log(m)n)次后，有n个元素。

也就是说要增长到n个的情况，需要log(m)n次。

每次移动m^i个元素，则共移动：

 用等比数列求和可以得到。

如果每次增长固定大小：

设每次增长k个

第一次k个元素，第二次2k个元素，第三次3k个元素....则n/k次后才会增长到n个元素。

每次移动k*i个元素，则共移动：

 等差数列求和可以求到。

倍增的方式复杂度在O(n)，而固定增长模式复杂度在O(n^2).

App消息的推送机制，用什么实现

目前的Push技术实现基本都是Client主动连接Server，钻牛角尖来讲，现在的Push其实都是伪Push。下面简单讲两种方式：
一、轮询法：
这种方法最简单，Client每过一段时间向Server请求一次数据。优缺点很明显，优点是实现简单；缺点是间隔时间不好控制，并且消耗大（电量、流量）。
二、长连接法：
还是从socket入手（又是这货？），Client使用socket连接Server，并且保持socket连接，Server随时可以通过这个socket发送数据给Client。

优点：最有效，客户端设备消耗比第一种小（设备应该从系统层对socket的长连接做优化，socket链接维护成本从客户端来讲应该是小于频繁的http请求的）；

缺点：服务端压力大，每一个设备都需要一个socket连接。
还有一些其他协议比如xmpp，其实也逃不过上面两种方式，只是做了一些封装。或者还有一种非互联网方式的做法，比如监听短信法，要push的时候，先发一条手机到目的手机，Client监听到了标的短信，然后向Server请求数据，不过像这类剑走偏锋的方法，限制条件也很多，不是很实用。
总结一下，目前各个推送平台的实现都是基于长连接法的，如果App要自己实现推送，也是建议使用这种方式。但是如果每个App都用一个长连接，那么手机也吃不消了，所以又有一些其他技术来实现，我们下篇再讲。

数组循环右移

如[1,2,3,4,5,6]右移两位：

[5,6,1,2,3,4]

暴力法需要每移动一个数都要整个数组右移，这样复杂度在O(n^2)

可以利用

[A B]逆置=[B逆置 A逆置]来实现

首先对A与B分别逆置：

[4 3 2 1 6 5]，然后整体逆置：[5 6 1 2 3 4]

逆置只要用两个指针指向首尾然后交换就好了，类似于字符串的翻转

C++怎么实现随机数

rand()与srand()

这两个都能生成随机数，生成后在要取的范围内取余，比如生成0~100的随机数，可以用rand%100

当需要负数时，比如[-2,2]，可以rand()%5，这时生成的是0~4，然后对rand()%5-2,即可得到-2~2

要取得[0,n)  就是rand（）%n     表示 从0到n-1的数

要取得[a,b)的随机整数，使用(rand() % (b-a))+ a; 
要取得[a,b]的随机整数，使用(rand() % (b-a+1))+ a; 
要取得(a,b]的随机整数，使用(rand() % (b-a))+ a + 1; 
通用公式:a + rand() % n；其中的a是起始值，n是整数的范围。 
要取得a到b之间的随机整数，另一种表示：a + (int)b * rand() / (RAND_MAX + 1)。 
要取得0～1之间的浮点数，可以使用rand() / double(RAND_MAX)。

rand与srand

rand:

计算机实际上并没有真正做到产生一个随机数，只是在一串预先定义好的数据中选择一个返回给函数。

当要产生多个随机数时，rand()会重复调用产生相同的数字序列。如果想要每次执行产生的随机数不同，就需要进行随机初始化。因此引入srand()函数.

srand:

void srand(unsigned seed);

功能：根据随机数生成器的种子seed的值初始化随机数。

 我们当然可以用数组和循环来设置种子的值，那么有没有什么我们可以直接利用的一直变化的值呢？

当然有，时间就是。我们可以借助time.h头文件中的time(NULL)返回机器当前的时间。

srand(time(NULL));

多重继承下的虚函数表

虚函数表，以及虚函数指针： 
1）每个有虚函数的类都有自己的虚函数表，每个包含虚函数的类对象都有虚函数表指针。 
2）对于多重继承，如果多个基类都有虚函数，则继承类中包含多个基类虚函数表，子类的虚函数地址放在声明的第一个基类虚函数表后面（即新增的虚函数:多态情况下基类指针只能调用派生类所重写的虚函数而不能调用新增的虚函数，因此增加在第一个虚表中不影响。如果想要调用新增的虚函数，要使用指针强制转换）。 
3）计算类对象的内存大小的时候，需要计算有多少个虚函数指针。

一般继承（无虚函数覆盖） 
假设有如下所示的一个继承关系： 

在这个继承关系中，子类没有重载任何父类的函数。那么，在派生类的实例中，其虚函数表如下所示：

对于实例：Derive d; 的虚函数表如下： 

我们可以看到下面几点：

1）虚函数按照其声明顺序放于表中。

2）父类的虚函数在子类的虚函数前面。

一般继承（有虚函数覆盖） 

我们从表中可以看到下面几点，

1）覆盖的f()函数被放到了虚表中原来父类虚函数的位置。

2）没有被覆盖的函数依旧。

多重继承（无虚函数覆盖） 
下面，再让我们来看看多重继承中的情况，假设有下面这样一个类的继承关系。注意：子类并没有覆盖父类的函数

 对于子类实例中的虚函数表，是下面这个样子：

1） 每个父类都有自己的虚表。

2） 子类的成员函数被放到了第一个父类的表中。（所谓的第一个父类是按照声明顺序来判断的）

这样做就是为了解决不同的父类类型的指针指向同一个子类实例，而能够调用到实际的函数。（强制转换的时候使用dynamic_cast）

多重继承（有虚函数覆盖） 
下面我们再来看看，如果发生虚函数覆盖的情况。

下图中，我们在子类中覆盖了父类的f()函数。

 我们可以看见，三个父类虚函数表中的f()的位置被替换成了子类的函数指针。

为什么构造函数不能定义为虚函数

虚函数相应一个指向vtable虚函数表的指针，但是这个指向vtable的指针事实上是存储在对象的内存空间的。假设构造函数是虚的，就须要通过 vtable来调用，但是对象还没有实例化，也就是内存空间还没有，怎么找vtable呢？所以构造函数不能是虚函数。

C++类型转换

static_cast

static_cast的转换格式：static_cast <type-id> (expression)

将expression转换为type-id类型，主要用于非多态类型之间的转换，不提供运行时的检查来确保转换的安全性。主要在以下几种场合中使用：

1. 用于类层次结构中，基类和子类之间指针和引用的转换；
   当进行上行转换，也就是把子类的指针或引用转换成父类表示，这种转换是安全的；
   当进行下行转换，也就是把父类的指针或引用转换成子类表示，这种转换是不安全的，也需要程序员来保证；
2. 用于基本数据类型之间的转换，如把int转换成char，把int转换成enum等等，这种转换的安全性需要程序员来保证；
3. 把void指针转换成目标类型的指针，是及其不安全的；

注：static_cast不能转换掉expression的const、volatile和__unaligned属性。

dynamic_cast

dynamic_cast的转换格式：dynamic_cast <type-id> (expression)

将expression转换为type-id类型，type-id必须是类的指针、类的引用或者是void *；如果type-id是指针类型，那么expression也必须是一个指针；如果type-id是一个引用，那么expression也必须是一个引用。

dynamic_cast主要用于类层次间的上行转换和下行转换，还可以用于类之间的交叉转换。在类层次间进行上行转换时，dynamic_cast和static_cast的效果是一样的；在进行下行转换时，dynamic_cast具有类型检查的功能，比static_cast更安全。在多态类型之间的转换主要使用dynamic_cast，因为类型提供了运行时信息

如果expression是type-id的基类，使用dynamic_cast进行转换时，在运行时就会检查expression是否真正的指向一个type-id类型的对象，如果是，则能进行正确的转换，获得对应的值；否则返回NULL，如果是引用，则在运行时就会抛出异常

安全使用dynamic_cast:

const_cast

const_cast的转换格式：const_cast <type-id> (expression)

const_cast用来将类型的const、volatile和__unaligned属性移除。常量指针被转换成非常量指针，并且仍然指向原来的对象（常量指针指指向常量的指针；指针常量指指针自己是一个常量）；常量引用被转换成非常量引用，并且仍然引用原来的对象。

reinterpret_cast

reinterpret_cast的转换格式：reinterpret_cast <type-id> (expression)

允许将任何指针类型转换为其它的指针类型；听起来很强大，但是也很不靠谱。它主要用于将一种数据类型从一种类型转换为另一种类型。它可以将一个指针转换成一个整数，也可以将一个整数转换成一个指针，在实际开发中，先把一个指针转换成一个整数，在把该整数转换成原类型的指针，还可以得到原来的指针值；特别是开辟了系统全局的内存空间，需要在多个应用程序之间使用时，需要彼此共享，传递这个内存空间的指针时，就可以将指针转换成整数值，得到以后，再将整数值转换成指针，进行对应的操作。

为什么要进行内存对齐?

cpu把内存当成是一块一块的，块的大小可以是2,4,8,16 个字节，因此CPU在读取内存的时候是一块一块进行读取的而不是一个字节一个字节读取，块的大小称为（memory granularity）内存读取粒度。

我们再来看看为什么内存不对齐会影响读取速度？

    假设CPU要读取一个4字节大小的数据到寄存器中（假设内存读取粒度是4），分两种情况讨论：

           1.数据从0字节开始

　　    2.数据从1字节开始

解析：当数据从0字节开始的时候，直接将0-3四个字节完全读取到寄存器，结算完成了。

        当数据从1字节开始的时候，问题很复杂，首先先将前4个字节读到寄存器，并再次读取4-7字节的数据进寄存器，接着把0字节，4,6,7字节的数据剔除，最后合并1,2,3,4字节的数据进寄存器，对一个内存未对齐的寄存器进行了这么多额外操作，大大降低了CPU的性能。

为什么空类的大小为1？

答：
1)空类也要给空间，标识在空间中的确存在过。当我们声明一个函数时，它必须在内存中占有一定的空间，否则无法得到这些事例。

2)操作系统对内存的读取是按照字节，因此即使是空类，也至少有一个字节，否则无法使用这些类。

3）举个例子：如果空类的大小为0，如果有两个空类A B，那么类创建的对象 a，b在内存上是重叠的（取地址 A B得到的就是相同的）——不符合语法或者操作系统规定

内存对齐规则：

struct或union成员对齐规则如下：

对齐规则如下：

原则一:存放的首地址偏移量 %  min(当前类型大小,对齐系数) == 0

原则二：结构体整体对齐，也称作二次对齐，结构体整体大小 % min(当前类型最大的大小,对齐系数) == 0

为什么默认的析构函数不是虚函数

因为只有在需要派生和多态的情况下才需要将析构函数声明为虚函数，如果不需要这些功能则没必要，因为虚函数会引入虚指针与虚函数表，从而引入不必要的浪费。

Shared_ptr的实现：

Shared_ptr实现值得注意的地方：

1.数据成员只有两个:

一个T*相当于真正的原始指针

一个count（这里为rm）计数保存引用计数，应该声明为static变量，这个变量属于全体类

2.什么时候调用指向对象的析构：

无论是reset还是调用赋值，还是shared_ptr自己析构，都要先判断引用计数的值，如果等于0，此时应该发生指向对象的析构

3.*与->的实现：

重载*与->:

对于*,应该返回*T，对于->应该返回指针T

template<typename T>
class Shared_Ptr
{
public:
	//用来接收一个指针
	Shared_Ptr(T* ptr) :mptr(ptr)
	{
		//由引用计数器负责增加指针的引用数
		AddRef();
	}
	//拷贝构造函数也会增加该指针的引用数
	Shared_Ptr(const Shared_Ptr<T>& rhs):mprt(rhs.mptr)
	{
		//同样增加引用交给引用计数器
		AddRef();
	}
	//赋值运算符的重载
	Shared_Ptr<T>& operator=(const Shared_Ptr<T>& rhs)
	{
		//判断自赋值
		if(this != &rhs)
		{
			//调用析构函数释放当前指针的指向
			this->~Shared_Ptr();
			mptr = rhs.mptr;
			AddRef();
		}
		return *this;
	}
	~Shared_Ptr()
	{
		//由引用计数器负责减少指针的引用数
		DelRef();
		//获取引用计数，若引用计数为0，则释放该指针
		if(GetRef() == 0)
		{
			delete mptr;
		}
		mptr = NULL;
	}
	//重载->运算符
	T* operator->()
	{
		return mptr;
	}
	//重载解引用运算符
	T& operator*()
	{
		return *mptr;
	}
	int GetRef()
	{
		//实质上返回的是引用计数器类中的 mptr 指针的引用计数
		return rm.getref(mptr);
	}
private:
	void AddRef()
	{
		rm.addref(mptr);
	}
	void DelRef()
	{
		rm.delref(mptr);
	}
	//Shared_Ptr的成员有一个 指针用来接收原生指针和 引用计数器
	T* mptr;
	//将引用计数器设置成静态成员，摆脱对类的依赖  ---记得在类外初始化
	static Ref_Manggement rm;
};

C++地址空间布局

一、首先进程地址空间的 1G 内核空间是给操作系统使用的，我们用户是没有操作权限的。
二、剩下的 3G 内存空间中，分为了栈区、内存映射段、堆区、数据段、bss段、代码段
1）栈区：这里的栈和数据结构的栈并不相同，数据结构的栈是一种后进先出的数据结构，而内存划分的栈是操作系统按照栈的特性，给用户划分出的内存区间。
   栈区一般存放：函数体的局部变量、函数调用期间的所有参数压栈、函数的返回值
注意栈区这段内存是由操作系统自己维护的，所以函数结束，在栈上的空间会由操作系统自己回收。

2）堆区：用户所操作的内存就是堆上的空间，用户可以使用 malloc / calloc / realloc / new 申请堆上的空间，但是用户申请堆上的空间必须自己手动释放，不然会造成内存泄漏。

3）内存映射段：里面存放 动态库 / 静态库，以及文件映射，匿名映射等等一切有依赖性的东西都在这段区域

4）一个程序本质上都是由 bss段、数据段、代码段组成的
   数据段：存放全局变量、静态类型的变量。当代码编译完后，在可执行程序这个文件中已经把这些数据的空间划分好了，这种类型的数据，在程序运行以前，操作系统就将数据段中的数据加载到内存了。也就是说在进入 main 函数之前这些数据已经划分好空间了。

   bss段：其实在 C 语言中，数据段中还有一个 bss 段，这里面存放的是未初始化的全局变量和静态数据，而数据段中存放的是已经初始化过的全局变量和静态数据。数据段中的所有数据已经划分好空间了，但是 bss 段并没有给其中的数据划分空间。

   代码段：存放可执行代码，以及只读常量(字符串常量等等)。这段内存是只读的（实际上对一个进程来说，它已经是一个可执行文件了，因此代码区存放的应该是机器指令而不是语言）。

链接

链接器是一个将编译器产生的目标文件打包成可执行文件或者库文件或者目标文件的程序。这个翻译比较拗口，不太好理解，这句话的意思具体如下：
首先是链接器的本质，链接器本质上也是一个程序，本质上和我们经常使用的普通程序没什么不同。
其次是链接器的输入，我们经常使用的程序比如播放器，其输入是一个MP4文件，而链接器的输入是编译器编译好的目标文件

最后是链接器的输出，链接器在将目标文件打包处理后，生成或者可执行文件，或者库，或者目标文件。

静态链接与动态链接

库与可执行文件

在链接器可操作的元素这一节中我们提到，链接器可以操作的最小单元为目标文件，也就是说我们见到的无论是静态库、动态库、可执行文件，都是基于目标文件构建出来的。目标文件就好比乐高积木中最小的零部件。

给定目标文件以及链接选项，链接器可以生成两种库，分别是静态库以及动态库，如图所示，给定同样的目标文件，链接器可以生成两种不同类型的库，接下来我们分别介绍。

静态库

假设这样一个应用场景，基础设计团队设计了好多实用并且功能强大的工具函数，业务团队需要用到里面的各种函数。每次新添加其中一个函数，业务团队都要去找相应的实现文件并修改链接选项。使用静态库就可以解决这个问题。静态库在Windows下是以.lib为后缀的文件，Linux下是以.a为后缀的文件。

为解决上述问题，基础设计团队可以提前将工具函数集合打包编译链接成为静态库提供给业务团队使用，业务团队在使用时只要链接该静态库就可以了，每次新使用一个工具函数的时候，只要该函数在此静态库中就无需进行任何修改。

你可以简单的将静态库理解为由一堆目标文件打包而成， 使用者只需要使用其中的函数而无需关注该函数来自哪个目标文件（找到函数实现所在的目标文件是链接器来完成的，从这里也可以看出，不是所有静态库中的目标文件都会用到，而是用到哪个链接器就链接哪个）。静态库极大方便了对其它团队所写代码的使用。

静态连接

静态库是链接器通过静态链接将其和其它目标文件合并生成可执行文件的，如下图一所示，而静态库只不过是将多个目标文件进行了打包，在链接时只取静态库中所用到的目标文件，因此，你可以将静态链接想象成如下图2所示的过程。

静态库是使用库的最简单的方法，如果你想使用别人的代码，找到这些代码的静态库并简单的和你的程序链接就可以了。静态链接生成的可执行文件在运行时不依赖任何其它代码，要理解这句话，我们需要知道静态链接下，可执行文件是如何生成的。

静态链接下可执行文件的生成

在上一节中我们知道，可以将静态链接简单的理解为链接器将使用到的目标文件集合进行拼装，拼装之后就生成了可执行文件，同时我们在目标文件里有什么这一节中知道，目标文件分成了三段，代码段，数据段，符号表，那么在静态链接下可执行文件的生成过程如图所示：

从下图中我们可以看到可执行文件的特点：

• 可执行文件和目标文件一样，也是由代码段和数据段组成。
• 每个目标文件中的数据段都合并到了可执行文件的数据段，每个目标文件当中的代码段都合并到了可执行文件的代码段。
• 目标文件当中的符号表并没有合并到可执行文件当中，因为可执行文件不需要这些字段。

可执行文件和目标文件没有什么本质的不同，可执行文件区别于目标文件的地方在于，可执行文件有一个入口函数，这个函数也就是我们在C语言当中定义的main函数，main函数在执行过程中会用到所有可执行文件当中的代码和数据。而这个main函数是被谁调用执行的呢，答案就是操作系统

静态链接是使用库的最简单最直观的形式， 从静态链接生成可执行文件的过程中可以看到，静态链接会将用到的目标文件直接合并到可执行文件当中，想象一下，如果有这样的一种静态库，几乎所有的程序都要使用到，也就是说，生成的所有可执行文件当中都有一份一模一样的代码和数据，这将是对硬盘和内存的极大浪费，假设一个静态库为2M，那么500个可执行文件就有1G的数据是重复的。如何解决这个问题呢，答案就是使用动态库。

动态库

动态库(Dynamic Library)，又叫共享库(Shared Library)，动态链接库等，在Windows下就是我们常见的大名鼎鼎的DLL文件了，Windows系统下大量使用了动态库。在Linux下动态库是以.so为后缀的文件，同时以lib为前缀，比如进行数字计算的动态库Math，编译链接后产生的动态库就叫做libMath.so。从名字中我们知道动态库也是库，本质上动态库同样包含我们已经熟悉的代码段、数据段、符号表。只不过动态库的使用方式以及使用时间和静态库不太一样。

在前面几个小节中我们知道，使用静态库时，静态库的代码段和数据段都会直接打包copy到可执行文件当中，使用静态库无疑会增大可执行文件的大小，同时如果程序都需要某种类型的静态库，比如libc，使用静态链接的话，每个可执行文件当中都会有一份同样的libc代码和数据的拷贝，如图所示，动态库的出现解决了此类问题。

动态库允许使用该库的可执行文件仅仅包含对动态库的引用而无需将该库拷贝到可执行文件当中。也就是说，同静态库进行整体拷贝的方式不同，对于动态库的使用仅仅需要可执行文件当中包含必要的信息即可，为了方便理解，你可以将可执行文件当中保存的必要信息仅仅理解为需要记录动态库的名字就可以了，如图所示，同静态库相比，动态库的使用减少了可执行文件的大小。

动态链接

 我们知道静态库在编译链接期间就被打包copy到了可执行文件，也就是说静态库其实是在编译期间(Compile time)链接使用的，那么动态库又是在什么时候才链接使用的呢，动态链接可以在两种情况下被链接使用，分别是load-time dynamic linking(加载时动态链接) 以及 run-time dynamic linking(运行时动态链接)，接下来我们分别讲解一下。

1.load-time dynamic linking(加载时动态链接)
首先可能有的同学会问，什么是load-time呢，load_time翻译过来也就是加载时，那么什么又是加载呢？
我们大家都玩过游戏，当我们打开游戏的时候经常会跳出来一句话：“加载中，请稍后。。。”和这里的加载意思差不多。这里的加载指的是程序的加载，而所谓程序的加载就是把可执行文件从磁盘搬到内存的过程，因为程序最终都是在内存中被执行的。

当把可执行文件复制到内存后，且在程序开始运行之前，操作系统会查找可执行文件依赖的动态库信息(主要是动态库的名字以及存放路径)，找到该动态库后就将该动态库从磁盘搬到内存，并进行符号决议(关于符号决议，参考符号决议一节)，如果这个过程没有问题，那么一切准备工作就绪，程序就可以开始执行了，如果找不到相应的动态库或者符号决议失败，那么会有相应的错误信息报告为用户，程序运行失败

从总体上看，加载时动态链接可以分为两个阶段：阶段一，将动态库信息写入可执行文件；阶段二，加载可执行文件时依据动态库信息进行动态链接。

2.接下来我们讲解第二种动态链接，run-time dynamic linking(运行时动态链接 

上一小节中我们看到如果我们想使用加载时动态链接，那么在编译链接生成可执行文件阶段时需要告诉编译器所依赖的动态库信息，而run-time dynamic linking 运行时动态链接则不需要在编译链接时提供动态库信息，也就是说，在可执行文件被启动运行之前，可执行文件对所依赖的动态库信息一无所知，只有当程序运行到需要调用动态库所提供的代码时才会启动动态链接过程。

我们在上一节中介绍了load-time，也就是程序加载时，那么程序加载完成后就开始程序执行了，那么所谓run-time(运行时)指的就是从程序开始被CPU执行到程序执行完成退出的这段时间。

所以运行时动态链接这种方式对于“动态链接”阐释的更加淋漓尽致，因为可执行文件在启动运行之前都不知道需要依赖哪些动态库，只在运行时根据代码的需要再进行动态链接。同加载时动态链接相比，运行时动态链接将链接这个过程再次推迟往后推迟，推迟到了程序运行时。

由于在编译链接生成可执行文件的过程中没有提供所依赖的动态库信息，因此这项任务就留给了程序员，在代码当中如果需要使用某个动态库所提供的函数，我们可以使用特定的API来运行时加载动态库，在Windows下通过LoadLibrary或者LoadLibraryEx，在Linux下通过使用dlopen、dlsym、dlclose这样一组函数在运行时链接动态库。当这些API被调用后，同样是首先去找这些动态库，将其从磁盘copy到内存，然后查找程序依赖的函数是否在动态库中定义。这些过程完成后动态库中的代码就可以被正常使用了。

相对于加载时动态链接，运行时动态链接更加灵活，同时将动态链接过程推迟到运行时可以加快程序的启动速度。

动态链接下可执行文件的生成

在静态链接下，链接器通过将各个目标文件的代码段和数据段合并拷贝到可执行文件，因此静态链接下可执行文件当中包含了所依赖的所有代码和数据，而与之对比的动态链接下可执行文件又是什么样的呢？
其实我们在动态库这一节中已经了解了动态链接下可执行文件的生成，即，在动态链接下，链接器并不是将动态库中的代码和数据拷贝到可执行文件中，而是将动态库的必要信息写入了可执行文件，这样当可执行文件在加载时就可以根据此信息进行动态链接了。为方便理解，我们将该信息仅仅认为是动态库都名字，真实情况当然要更复杂一点，这里我们以Linux下可执行文件即ELF文件为例

在前几节中我们将可执行文件简单的划分为了两段，数据段和代码段，在这里我们继续丰富可执行文件中的内容，如图所示，在动态链接下，可执行文件当中会新增两段，即dynamic段以及GOT（Global offset table）段，这两段内容就是是我们之前所说的必要信息。

dynamic段中保存了可执行文件依赖哪些动态库，动态链接符号表的位置以及重定位表的位置等信息

当加载可执行文件时，操作系统根据dynamic段中的信息即可找到使用的动态库，从而完成动态链接(运行时动态链接是不需要这些信息的)

动态库与静态库的对比

动态链接的优点：

动态链接下可执行文件当中仅仅保留动态库的必要信息，因此解决了静态链接下磁盘浪费问题。

静态链接在内存中就会有成百上千份同样的libc代码，这对于宝贵的内存资源同样是极大的浪费，而使用动态链接，内存中只需要有一份libc代码，所有的程序（进程）共享这一份代码，因此极大的节省了内存资源

如果我们修改了动态库的代码，我们只需要重新编译动态库就可以了而无需重新新编译我们自己的程序，因为可执行文件当中仅仅保留了动态库的必要信息，重新编译动态库后这些必要都信息是不会改变的

动态链接的缺点：

首先由于动态库是程序加载时或运行是才进行链接的，因此同静态链接相比，使用动态链接的程序在性能上要稍弱于静态链接

动态链接下的可执行文件不可以被独立运行（这里讨论的是加载时动态链接，load-time dynamic link），换句话说就是，如果没有提供所依赖的动态库或者所提供的动态库版本和可执行文件所依赖的不兼容，程序是无法启动的。动态库的依赖问题会给程序的安装部署带来麻烦，在Linux环境下尤其严重，以笔者曾参与开发维护的一个虚拟桌面系统为例，我们在开发过程中依赖的一些比较有名的第三方库默认不会随着安装包发布，这就会导致用户在较低版本Linux中安装时经常会出现程序无法启动的问题，原因就在于我们编译链接使用都动态库和用户Linux系统中的动态库不兼容。解决这个问题的方法通常有两种，一个是用户升级系统中都动态库，另一个是我们讲需要都第三方库随安装包一起发布

静态链接的优点：

静态链接都最大优点就是使用简单，编译好的可执行文件是完备的，即静态链接下的可执行文件不需要依赖任何其它的库，因为静态链接下，链接器将所有依赖的代码和数据都写入到了最终的可执行文件当中，这就消除了动态链接下的库依赖问题

静态链接的缺点：

静态链接会导致可执行文件过大，且多个程序静态链接同一个静态库的话会导致磁盘浪费的问题。

左值，纯右值和将亡值

左值

能够用&取地址的表达式是左值表达式

纯右值

1）本身就是赤裸裸的、纯粹的字面值，如3、false；
2）求值结果相当于字面值或是一个不具名的临时对象。

++i是左值，i++是右值
      前者，对i加1后再赋给i，最终的返回值就是i，所以，++i的结果是具名的，名字就是i；而对于i++而言，是先对i进行一次拷贝，将得到的副本作为返回结果，然后再对i加1，由于i++的结果是对i加1前i的一份拷贝，所以它是不具名的。假设自增前i的值是6，那么，++i得到的结果是7，这个7有个名字，就是i；而i++得到的结果是6，这个6是i加1前的一个副本，它没有名字，i不是它的名字，i的值此时也是7。可见，++i和i++都达到了使i加1的目的，但两个表达式的结果不同。

将亡值

C++11中的将亡值是随着右值引用的引入而新引入的。换言之，“将亡值”概念的产生，是由右值引用的产生而引起的，将亡值与右值引用息息相关

在C++之中，使用左值去初始化对象或为对象赋值时，会调用拷贝构造函数或赋值构造函数。而使用一个右值来初始化或赋值时，会调用移动构造函数或移动赋值运算符来移动资源，从而避免拷贝，提高效率。 而将亡值可以理解为通过移动构造其他变量内存空间的方式获取到的值。在确保其他变量不再被使用、或即将被销毁时，来延长变量值的生命期。而实际上该右值会马上被销毁,所以称之为：将亡值。

1）返回右值引用的函数的调用表达式（X&& 即为右值引用。指返回值为右值引用的函数）

2）转换为右值引用的转换函数的调用表达式（如move,将一个左值转换为一个右值:test(move(test2));这里test2通过move被转换为一个右值从而避免对test调用拷贝构造）

另外： 

1）字符串字面值是左值。

      不是所有的字面值都是纯右值，字符串字面值是唯一例外。"abc"是左值

2)  具名的右值引用是左值，不具名的右值引用是右值

如下面，x是左值，而get_a_X()是右值（get_a_X()返回类型为右值引用）

实际上过程是get_ax_X()生成一个右值（不具名），然后调用移动构造函数构造x.x是一个左值，像X anotherX=x将调用拷贝构造函数,执行后x不发生变化，而get_a_X()生成的那个值成为将亡值

X& foo(X&& x)
{
     //对x进行一些操作
     return x;
}

//调用
foo(get_a_X());

左值和右值的概念：

左值：能取地址，或者具名对象，表达式结束后依然存在的持久对象；

右值：不能取地址，匿名对象，表达式结束后就不再存在的临时对象；

区别：

左值能寻址，右值不能；

左值能赋值，右值不能；

左值可变，右值不能（仅对基础类型适用，用户自定义类型右值引用可以通过成员函数改变）；

默认构造函数与拷贝构造函数的调用：

以下：

A b;调用默认构造函数；

A a=b;调用拷贝构造函数

class A
{
public:
	A()
	{
		cout<<"Agouzao"<<endl;
	}
	A( A&)
	{
		cout<<"Arrrr"<<endl;
	}
};
int main()
{
	A b;
	A a=b;
	cout<<endl;
}

以下:

只在A b;时调用默认构造函数，而对A* a=&b没有任何操作，因为只是调整指针指向而已

class A
{
public:
	A()
	{
		cout<<"Agouzao"<<endl;
	}
	A( A&)
	{
		cout<<"Arrrr"<<endl;
	}
};
int main()
{
	A b;
	A* a=&b;
	cout<<endl;
}

以下：

A* a=new A;将调用默认构造函数（注意区分A a=b;与A* a=new A的区别）

class A
{
public:
	A()
	{
		cout<<"Agouzao"<<endl;
	}
	A( A&)
	{
		cout<<"Arrrr"<<endl;
	}
};
int main()
{
	A* a=new A;
	cout<<endl;
}

以下：

首先调用A的默认构造函数，然后调用B的默认构造函数

这是因为先调用基类，后调用派生类

class A
{
public:
	A()
	{
		cout<<"Agouzao"<<endl;
	}
	A( A&)
	{
		cout<<"Arrrr"<<endl;
	}
};
class B:public A
{
public:
	B()
	{
		cout<<"Bgouzao"<<endl;
	}
	B( B&)
	{
		cout<<"brrrr"<<endl;
	}
};
int main()
{
	A* a=new B;
	cout<<endl;
}

线程同步的方式：

1.互斥量

2.读写锁

3.条件变量

4.自旋锁

单链表的排序

leetcode 148

在 O(n log n) 时间复杂度和常数级空间复杂度下，对链表进行排序。

快排：

思路：

对于单链表，使用传统的Parition方式是行不通的，因为无法向前遍历而只能向后遍历，因此要换个方式来进行Parition

对于[head,tail]上的节点，考虑head作为flag位。

用两个指针mid与pCur。mid用于分割链表，mid左侧的都小于mid,mid右侧的都大于等于mid。

pCur用于遍历两边，当pCur->val<flag时，说明这个pCur比flag小，应该放在mid左侧，因此首先将mid=mid->next,这是为了给这个pCur腾出位置，现在的mid由于进行了->next，因此它并不一定满足小于flag,无论他到底小不小于，我们进行swap(mid,pCur)，注意这里的swap只是交换节点的值，交换后的mid的值一定满足小于flag了。然后将pCur=pCur->next;进行下一个点的遍历。

如果pCur大于flag,说明这个点本就应该在mid右侧，因此mid不因腾出位置来，因此将pCur=pCur->next。

这个过程实际上就是，在[head,mid]间的元素一定是小于flag的，而在(mid,pCur)间的元素一定是大于flag的，当我们的pCur遍历完，实际上就变成了[head,mid]一定小于flag,[mid+1,end)一定大于flag。即现在mid就是分割点，但此时mid的值并不是分割点flag，因此我们swap(mid,head),这样mid的值既为flag，也是分割点。

另外注意：

pCur->val<flag不能改为pCur->val<=flag

因为如果改成小于等于，则对[5,5]这种情况，将无限递归，因为QuickSort(5,5)中，Partition的结果指向第二个5，则下一个QuickSort(5,5)又将重复这个过程。

	class Solution {
	public:
		ListNode* sortList(ListNode* head) {
			if(!head)
				return NULL;
			ListNode* tail=head;
			while(tail->next)
				tail=tail->next;
			QuickSort(head,tail);//4 2 5 3 7 9 0 1
			return head;
		}
		void QuickSort(ListNode* head,ListNode* tail)
		{
			if(head==tail)
				return;
			auto mid=Parition(head,tail);
			QuickSort(head,mid);
			if(mid==tail)
				return;
			QuickSort(mid->next,tail);
			return ;
		}
		ListNode* Parition(ListNode* head,ListNode* tail)
		{
			ListNode* pCur=head->next;
			ListNode* mid=head;
			int flag=head->val;
			while(pCur!=tail->next)
			{
				if(pCur->val<flag)
				{
					mid=mid->next;
					swap(pCur,mid);
				}
				pCur=pCur->next;
			}
			swap(mid,head);
			return mid;
		}
		void swap(ListNode* a,ListNode* b)
		{
			int c=a->val;
			a->val=b->val;
			b->val=c;
		}
	};

归并排序：

 归并排序的话相对好写，只要找到中点然后对中点左部分的链表断链，然后递归左右两边的链表，最后merge即可

问题在于中点的找寻，这里用slow-fast指针就好了

class Solution {
public:
    ListNode* sortList(ListNode* head) {
        if(!head)
			return NULL;
		ListNode* pCur=head;
		while(pCur->next)
			pCur=pCur->next;
		return MergeListCore(head,pCur);
    }
	ListNode* MergeListCore(ListNode* head,ListNode* tail)
	{
		if(head==tail||!head->next)
			return head;
		ListNode* p1=head;
		ListNode* p2=p1->next->next;
		while(p2)
		{
			p1=p1->next;
			p2=p2->next;
			if(!p2)
				break;
			p2=p2->next;
		}
		auto tmp=p1->next;
		p1->next=NULL;
		auto l1=MergeListCore(head,p1);
		auto l2=MergeListCore(tmp,p2);
		p1=l1;p2=l2;
		ListNode* phead=new ListNode(0);
		ListNode* pCur=phead;
		while(p1&&p2)
		{
			if(p1->val<=p2->val)
			{
				pCur->next=p1;
				p1=p1->next;
			}
			else
			{
				pCur->next=p2;
				p2=p2->next;
			}
			pCur=pCur->next;
		}
		if(p1)
			pCur->next=p1;
		if(p2)
			pCur->next=p2;
		return phead->next;
	}
};

　　链表中点的寻找是很常见的一种工具，每次自己临时写在链表里特别容易出问题，所以下面的为寻找链表中点的模板，熟悉之后果断用就行，避免因为这个地方出问题而崩盘

ListNode* FindMid(ListNode*head)
{
	ListNode* slow=head;
	ListNode* fast=slow;
	ListNode* brk=head;
	while(fast&&fast->next)
	{
		fast=fast->next->next;
		brk=slow;
		slow=slow->next;
	}
	//brk->next=NULL//断链为两部分
	return brk;
}

网络字节流与主机字节流

字节流分为两类

char str[1024] = { 0 };//全局静态区
void main1()
{
	int *p1 = new int[10]{1, 2, 3, 4, 5, 6, 7, 8, 9, 0};//堆上创建  开辟的内存
	int *p2 = new (str)int[10]{1, 2, 3, 4, 5, 6, 7, 8, 9, 0};//ok   在str字段处开始   分配内存
	int *p3 = new (str+40)int[10]{1, 2, 3, 4, 5, 6, 7, 8, 9, 0};//ok    str+40 在str字段处的后40字节数处开始分配
	for (int i = 0; i < 10; i++)
	{
		cout << p1[i] << "	" << p1 + i << "	" << p2[i] << "	" << p2 + i << endl;
	}
	cout << endl;
	p1 = new int[10]{1, 2, 3, 4, 5, 6, 7, 8, 9, 0};//堆上创建  开辟的内存
	p2 = new (str)int[10]{1, 2, 3, 4, 5, 6, 7, 8, 9, 0};//在str字段处开始   分配内存
	for (int i = 0; i < 10; i++)
	{
		cout << p1[i] << "	" << p1 + i << "	" << p2[i] << "	" << p2 + i << endl;
	}
	cin.get();