栈

程序的局部变量、临时变量、函数的参数、函数的返回值等系统自动分配的变量都是在栈里分配，当前执行代码的指针也是存放在栈里面，而我们用malloc或new申请的内存是在堆里分配的。栈里分配的内存由系统进行管理，无需手动释放，而堆里分配的内存需要用户手动释放。栈的大小是在编译时确定的，编译后其大小就不可改变。在VC中栈的大小默认为1MB，其大小可在VC的[项目]-[属性]-[Linker]-[系统]下修改。可以看到这里有2个与栈大小相关的设定：reserve与reserve,commit，他们的区别见虚拟地址空间。

注意栈的大小只影响.exe程序，而不会影响dll程序。

虚拟地址空间

Win32用虚拟地址空间来管理进程的内存，在Win32中一个进程最多可用4GB的内存。

下图描述了各种分配的关系：

 Win32中一个进程可能要用比当前可用的物理内存还多的内存，系统会把一部分内存里的内容挪到硬盘上，这称为换页。进程的虚拟地址空间对内存的组织以页(Page)为单位，在x86机器上页的大小是4KB。当一个进程调用一个DLL时，DLL分配的内存是在调用进程的地址空间内。若希望一块内存可被别的进程访问，可创建一个文件映像(File Mapping)。

一个虚拟内存空间的页有以下3种状态：

Free：未被使用，进程无法访问这样的页。

Reserve：被预留。被预留的空间将不可被别的内存分配函数（如malloc）使用。这样的页并未与实际的物理内存相关联，因此进程无法访问这样的页。

Commit：实际分配了的页。这样的页可被进程访问，但受到访问权限的限制。只在第一次读写时系统会把这样的页载入物理内存，当进程结束后系统会释放这样的页占据的物理空间。

虚拟地址空间主要相关函数：

VirtualAlloc：分配空间，使用参数MEM_COMMIT|MEM_RESERVE实际分配空间。

VirtualFree：释放空间

VirtualLock与VirtualUnlock：让空间驻留在内存中，防止空间的内容被交换到硬盘上

VirtualProtect：修改空间的访问权限

堆分配

要使用堆分配首先要创建一个堆，堆是进程拥有的一种对象，创建了堆我们就得到了这个对象的句柄(Handle)。在进程创建时系统会为进程创建一个默认堆，这个堆的大小默认 为1MB，其大小可在VC的[项目]-[属性]-[Linker]-[系统]下修改，其说明参考栈。在销毁堆时会一并销毁分配在堆上的对象，但要注意此时指向对象的指针会成为野指针。

堆操作主要相关函数：

GetProcessHeap：得到进程的默认堆，要注意的是我们使用的C Run-Time Library的malloc()函数并不是在 这个默认堆上分配空间的

GetProcessHeaps：得到进程的所有堆对象，包括C Run-Time Library的堆_crtheap

HeapCreate：创建堆

HeapAlloc：在堆上分配空间

HeapFree：释放空间

HeapDestory：销毁堆

HeapLock与HeapUnlock：线程调用这个函数来防止别的线程访问这个堆，其参数为HeapCreate或GetProcessHeap的返回值。

HeapWalk：枚举指定堆对象的所有内存块，在多线程程序中枚举前要用HeapLock锁定堆。

HeapValidate：此函数检查堆的正确性，他有3个参数：hHeap为要检查的堆的句柄，dwFlags一般设为0，lpMem指定要检查的内存块，设为NULL则检查整个堆。返回非0表示内存块有效，返回0表示有内存块已被破坏。

Global与Local函数

Global与Local函数是为兼容以前的16位Windows而设计的，他们的速度较慢，Win32中应该使用堆函数，而不使用Global与Local函数。Global与Local的内存分配是在进程的默认堆上，就是GetProcessHeap()返回的堆。

标准C库函数

在Windows平台的C Run-Time Library中的malloc()和free()是通过调用堆函数来实现的。值得注意的是C Run-Time Library拥有独立的堆对象，我们知道，当一 个应用程序初始化的时候，首先被初始化的是C Run-Time Library，然后才是应用程序的入口 函数，而堆对象就是在C Run-Time Library被初始化的时候被创建的，这个 堆对象被称为_crtheap（这个堆与GetProcessHeap()返回的堆不是一个堆），malloc()在这个堆上 分配内存(new实际调用malloc()分配内存)，就是说malloc()的实际操作 类似于HeapAlloc(_crtheap，size)。对于动态链接的C Run-Time Library,运行库只被初始化一 次，而对于静态连接的运行库，每链接一次就初 始化一次，所以对于每个静态链接的运行库都拥有彼此不同 的堆对象，也就是说会存在多个_crtheap。如果一个应用程序调用了多个DLL,除了一个DLL外，其他的DLL，包括应用程序本身动态连接运行库，这样他们就使用同一 个堆对象。而有一个DLL使用静态连接的运行库，它就拥有一个和其 他DLL不同的堆对象，因此DLL中分配的内 存要在DLL中释放。

进程和线程都是由操作系统所体会的程序运行的基本单元，系统利用该基本单元实现系统对应用的并发性。进程和线程的区别在于：

简而言之,一个程序至少有一个进程,一个进程至少有一个线程.
线程的划分尺度小于进程，使得多线程程序的并发性高。
另外，进程在执行过程中拥有独立的内存单元，而多个线程共享内存，从而极大地提高了程序的运行效率。
线程在执行过程中与进程还是有区别的。每个独立的线程有一个程序运行的入口、顺序执行序列和程序的出口。但是线程不能够独立执行，必须依存在应用程序中，由应用程序提供多个线程执行控制。
从逻辑角度来看，多线程的意义在于一个应用程序中，有多个执行部分可以同时执行。但操作系统并没有将多个线程看做多个独立的应用，来实现进程的调度和管理以及资源分配。这就是进程和线程的重要区别。

进程是具有一定独立功能的程序关于某个数据集合上的一次运行活动,进程是系统进行资源分配和调度的一个独立单位.
线程是进程的一个实体,是CPU调度和分派的基本单位,它是比进程更小的能独立运行的基本单位.线程自己基本上不拥有系统资源,只拥有一点在运行中必不可少的资源(如程序计数器,一组寄存器和栈),但是它可与同属一个进程的其他的线程共享进程所拥有的全部资源.
一个线程可以创建和撤销另一个线程;同一个进程中的多个线程之间可以并发执行.

============================================================

堆：　是大家共有的空间，分全局堆和局部堆。全局堆就是所有没有分配的空间，局部堆就是用户分配的空间。堆在操作系统对进程初始化的时候分配，运行过程中也可以向系统要额外的堆，但是记得用完了要还给操作系统，要不然就是内存泄漏。

数组要么在静态存储区被创建（如全局数组），要么在栈上被创建。数组名对应着（而
不是指向）一块内存，其地址与容量在生命期内保持不变，只有数组的内容可以改变。

例如：

void main(void)
{
    int a[10];
    a ++;//error, a is left value,but can't be changed.
}

指针可以随时指向任意类型的内存块,远比数组灵活，但也更危险。 下表是指针和数组一个简单的比较

数组和指针的特点 数组 指针
保存数据 保存地址
直接访问数据 间接访问数据，先取得指针的内容，然后以它为地址，取得数据 
用于存储数目固定且类型相同的数据 通常用于动态数据结构
由编译器自动分配和删除 动态的分配和删除，相关函数为malloc() 和free()
自身即为数据名 通常指向隐式数据

1、指针和数组都可以在初始化的时候赋予字符串常量。尽管看上去一样，底层机制却不同。

指针在定义的时候，编译器并不会为指针所指向的对象分配内存空间，它只是分配指针变量的空间。除非以一个字符串常量对其进行初始化。下面的定义创建了一个字符串常量（为其分配了内存空间）

char *p = "abcd";

在ANSI C中，初始化指针时所指向的字符串被定义为只读，如果想通过指针修改字符串的时候，会产生未定义的行为。

数组也可以用字符串常量进行初始化，但是其内容可以被修改。

2、内容的复制和比较

不能对数组进行字节复制和比较，对于两个数组a,b,不能用b=a进行复制，而应当使用标准库函数strcpy()。也不能使用if(b==a)进行比较，应当使用strcmp()。

而对于指针p，如果要想将数组a中的内容复制，要先申请一块内存区域，然后使用strcpy()进行拷贝。

void main(void )
{ 
    char a[] ="hello";
    char b[10];
    strcpy(b,a); // can't use b=a;
    if(strcmp(b,a) == 0);//can't use if(b==a)
    char *p = NULL;
    p = (char *)malloc(sizeof(char *)*(strlen(a)+1)；
        strcpy(p, a);
    if(strcmp(b,a) == 0);
}

3、计算内存容量

 用运算符sizeof()可以计算出数组的容量（字节数）。如下例

char a[] = "abcdef";

char *p = a;

sizeof(a) = 7; 

sizeof(p) = 4;//sizeof(p) equal to sizeof(char *) =4

注意当数组名作为函数参数进行传递时，该数组自动退化该类型的指针，如下例：

void TEST(char a[100])
{
     cout<<sizeof(a)<<endl;// in this place, sizeof(a) is equal to sizeof(char *) = 4
}

个人观点：本来想再写一些关于指针和数组的相同之处，但是我觉得对于二者讨论的太多反而会让人更加模糊二者该如何使用，陷入到理论的牛角尖中。如果大家非要搞清楚的话，可以参考《C专家编程》。只要我们可以正确的使用，就没有必要太深究吧，有时候钻的越深，反而越不知如何使用。

什么是回调函数

简而言之，回调函数就是一个通过函数指针调用的函数。如果你把函数的指针（地址）作为参数传递给另一个函数，当这个指针被用为调用它所指向的函数时，我们就说这是回调函数。

为什么要使用回调函数

   因为使用回调函数可以把调用者和被调用者分开，调用者不关心谁是被调用者，所有它需知道的，只是存在一个具有某种特定原型、某些限制条件（如返回值为int）的被调用函数。回调函数就好像是一个中断处理函数，系统在符合你设定的条件时自动调用。

如何使用回调函数

 使用回调函数，我们需要做三件事：

• 声明
• 定义
• 设置触发条件：在你的函数种把你的回调函数名称转化为地址作为一个参数，以便于系统调用。

声明和定义时应注意，回调函数由系统调用，所以可以认为它属于windows系统，不要把它当作你的某个类的成员函数。

回调函数是一个程序员不能显示调用的函数，通过将回调函数的地址传给调用者从而实现调用。回调函数是十分必要的，在我们想通过一个统一接口实现不同的内容，这时回调函数非常合适。

函数指针的声明

对回调函数有了一个初步的了解，下面我们来说一下函数指针。因为要实现回调，必须首先定义函数指针。

void (*) ()

左边圆括弧中的星号是函数指针声明的关键。另外两个元素是函数的返回类型（void）和右边圆括弧中的入口参数

为函数指针声明类型定义：

Typedef void(* pfv)()

pfv 是一个函数指针，它指向的函数没有输入参数，返回类型为voie。使用这个类型定义名称可以隐藏负责的函数指针语法。

void (*p)();

void func()

{

……

}

p = func;

p的赋值可以不同，但一定要是函数的指针，并且参数和返回类型相同。

例如：

现学现卖的一个小例子

#include <iostream>
using namespace std;

typedef void (*PF)();
void func()
{
  cout << "func" << endl;
}

void caller( PF pf)
{
  pf();
}

int main()
{
  PF p = func;
  caller(p);

  system("pause");

  return 0;
}

调用约定

在visual c++中，可以在函数类型前加_cdecl,_stdcall或者_pascal来表示调用规范（默认为_cdecl）。调用规范影响编译器产生的给定函数名，参数传递的顺序，堆栈清理责任以及参数传递机制。

不过，在win32的程序中，我见得比较多的是CALLBACK，这个宏定义在windef.h中，

#define CALLBACK    __stdcall

它约定了函数在它们返回到调用者之前，都会从堆栈中移除掉参数。

摘自：

回调函数

http://hi.baidu.com/spidermanzy/blog/item/b25b00956469c6097bf48016.html

回调函数以及钩子函数的概念

http://zq2007.blog.hexun.com/9068988_d.html

声明函数指针并实现回调

http://www.vckbase.com/document/viewdoc/?id=195

2.关于C语言调用未声明的函数：
C语言中，编译器中允许调用未声明的函数，并按照实参猜测函数原型，这是危险的。在C++中不能调用未声明的函数。

3.关于编译和链接：
编译是对语法的检查，链接是对外部引用的替换。由于文件是单独编译的，对于对外部函数的调用在编译时会保留一个引用（因为编译的时候编译器只知道这个函数像什么而不知道是什么，只看到声明未看到定义），在链接时会从别的.obj或.o文件中找到此函数地址，并用之代替对此函数调用的引用。

4.编译器需要知道正在编译的程序是c还是c++，而编译器是不直接编译头文件的，所以无论c还是c++，头文件都是.h，而源文件有.c和.cpp之别。(这个当时有点扯淡)
ps:编译器一般不会对头文件的扩展名限制吧，cpp标准头文件不就没有扩展名吗，还有的诗.hpp. 一些系统上cpp文件以.cc结束，具体是什么取决于编译器，取决于用户。

5.关于为什么把函数作为类的成员的一个直观想法：
为了避免名字冲突，因为struct内部的名字是不会和外部冲突的，而函数名又是稀缺的资源，有些函数又是专门作用在struct上的，并无它用，那为什么不把该函数作为struct的内部成员呢？

6.关于成员函数参数列表中看不见的参数this：
RT，是编译器负责的。

7.关于定义多个对象时，成员函数的代码有多份吗：
当然不是，只有一份。
ps:多个进程呢？

8.关于::运算符：
C++用把函数作为类和结构的成员的方法解决了名字分解的问题，但是实际上C++的名字是分两部分的：
范围::名字。需要指出名字的范围时，即分解名字时，用它，这也是相对C语言新增添的运算符，叫“范围分解运算符”。
比如，在外部定义成员函数时就用到此操作符。
ps:名字查找问题，远不止这两种，局部块，类域，父类，namespace，全局，未完待续。。。

9.关于外部定义成员函数时，函数体内部对成员变量的操作是否也需要加::操作符：
不用，编译器没那么笨。说明一次就够了，交给编译器吧。
在一个成员函数的内部，可以直接提及任何一个类的成员（包括成员变量和成员函数），编译器在在全局搜寻此名字前会先在局部结构的名字中搜索。
想用该结构地址时，用this即可。

10.关于.h和.cpp：
类定义放在.h，类成员函数定义放在.cpp。

11.C可以用void*指针和其它任何类型指针之间互相赋值。C++只允许用其它类型指针给void*赋值。

12.关于“向对象发送消息”：
object.memberfunction(arglist);
以上语句是调用某对象的成员函数，在OOP中，也叫向某对象发送消息，让它自己完成某项操作，这样的“对象”的概念体现得更明显。OOP要做的事就是设计好对象和消息，然后向对象发送消息。

13.关于没有成员变量的类的sizeof()：
会返回一个很小的非零值，VS2005是1，对于既有成员变量又有成员函数的类，sizeof求大小的时候只计算成员变量所占空间，不加此非零值。
 PS:一个对象的存在的唯一标识，不是名字，而是地址，对于无数据类的对象的定义，编译器为其分配一个char以示标识。

14.C++对象的生命期是到定义它所在的程序块的右大括号为止，在新编译器中，编译器默认为每个for循环加上大括号，即使原来并没有。
PS:这个有点意思，难道编译器在语法分析时会给for添加花括号？然后在去掉？有意思。

15.C++编译器如此重视对象的初始化以至于它会检查对象的定义（对于对象来说，定义即初始化，因为在定义时编译器会自动插入构造函数用于初始化对象）是否会因为goto语句或者switch-case语句而被跳过。在VS2005编译器下，goto跳过一个对象的初始化会产生一个警告，switch-case则会产生一个错误。在GCC编译器下，则两者都是错误。

16.malloc(),calloc(),realloc()都从堆上分配内存，意味着需要用free()去释放，free()做的工作实际是告之编译器（？）这些内存可以被再次分配。上述三个分配内存的函数如果调用失败（比如当前堆不够用了）都会返回0，可以用assert()断言。

PS:*alloc, free都是运行时的，申请与释放内存怎可能与编译器交互？C程序有自己的运行时库CRT，alloc,free直接向CRT提交申请，由CRT与操作系统交涉。当然也可以绕过CRT。

17.assert()实际是在assert.h中定义的宏，取一个可以判断真假的表达式为参数，“必真，否则打印并推出”。

18.关于类嵌套定义：
类可以嵌套定义，在A类的内部定义B类，并声明B类的一个（或多个）对象为A类的成员。个人认为，此举除了名字范围划分外，和在类外定义一个新类无区别。要想让B类对象访问A类私有成员仍然需要声明其为友元――friend A::B;?所有友元声明都应放在类定义内部，因为这是给编译器看的。多从编译器的角度想问题，很多规则就变得理所当然了。

19.关于存取块：
这里，存取块指的是类定义内部由一个存取控制符（public,protected,private）开始到下一个存取控制符为止，中间的部分。
在一个存取块内的对象在内存中都是相邻的，各存取块之间通常也是按定义顺序存储的，但不绝对，因为有些机器对private提供支持，将其放在特殊位置。
PS:机器会对private支持？编译器吧。

20.关于存取限制及想办法访问私有成员：
存取指定消息（public,protected,private）只能作用到编译阶段，也就是说是对写代码阶段的限制。到了运行阶段存取限制标志已经消失，对象就是一个存储区域，如果有人想通过指针移动和格式转换来读取到私有成员，是可以做到的，C++对此无能为力。

21.要产生一个指向某结构或某类的指针，只需要该结构或类的声明而无需定义，因为指针的大小是确定的，而所指之物的大小不是必须知道的。

22.关于构造函数与析构函数的名字和返回值：
构造函数与析构函数必须与类同名，这是为了编译器能够立刻查找到它们，因为它们是由编译器负责调用的，实际上是由编译器负责在编译阶段将它们插入到原有的代码中，构造函数插入到定义处，析构函数插入到定义所在的代码块的右大括号处。
构造函数与析构函数都没有返回值，这与返回void不同，因为编译器负责调用它们，而编译器不可能知道如何处理返回值，所以它们没有返回值。

ps:插入用在这里不合适，有点展开的意思。对于非显式的构造与析构，编译器为其生成，并放入.text段，再在合适的时机调用，比如全局构造在_start，局部的在其定义处，局部对象有些特殊，还需另行讨论。
23.关于explicit和aggregate：
先说aggregate。aggregate类型可以使用大括号初始化。这种初始化方式，个人认为是调用了拷贝构造函数（见24）。
aggregate类型是指array或者是没有用户定义构造函数，没有私有或保护非静态成员变量，没有基类，没有虚函数的class类型。
在有构造函数的情况下，还有一种情况可能可以用大括号对对象进行初始化。
对于只有一个参数的构造函数，如果在初始化时提供此构造函数所需参数类型的参数，那么系统会自动调用此构造函数对对象进行初始化。这有可能是违背程序员意愿的，阻止方法是将构造函数声明为explicit，这样此构造函数就不能用来进行类型转换了。
在这种情况下，如果用一个大括号初始化一个对象数组是可以成功的。

24.关于拷贝构造函数：
如果你的类没有添加拷贝构造函数，编译器也会为你添加一个默认的拷贝构造函数，用于通过其它对象的const&来构造新的对象编译器默认生成的拷贝构造函数以“位拷贝”的方式工作。一般情况下，使用编译器提供的默认拷贝构造函数就可以了，除非你的类中有指针成员，因为指针成员存储buffer地址，而通过此地址对数据进行操作，如果直接拷贝就会出现两个对象只有一份数据的情况，会造成错误。正确的做法是，重新开辟内存，拷贝指针所指数据信息，给指针成员赋值。

25.关于编译器自动产生的缺省构造函数：
编译器在类定义中没有任何构造函数的情况下提供缺省构造函数。
工作原理如下：
1.全局变量（一般为定义在所有函数之外的变量），静态全局变量和静态变量的默认值为0。
2.局部变量默认值为随机数。
看来编译器自动产生的缺省构造函数还是很不靠谱的。
ps:上面说的两点似乎是普通变量的初始化，而不是类的构造。全局、静态变量、对象在编译时已经分配了空间，而局部的变量、对象，是运行时在栈上创建的，编译器”无能为力”，若想为其初始化，就必须添加额外的”指令”，而这不是每个人都想要的，于是编译器把它留给了coder.

26.关于如何隐藏私有成员：
C++中类的定义，能够隐藏私有成员的实现，却无法防止类库的使用者看到私有成员的类型，因为必须要提供类定义，而类定义中一般含有类的全貌。解决办法是将私有成员放在结构体里，然后在类定义中只将指向此结构体的指针作为成员。在声明此指针时只需要该结构体的声明而非定义，这样就可以掩盖结构体的内部。
此技术成为handle classes或者Cheshire cat。

27.可以用引用初始化引用。如下列程序：
?int i = 5;
?int &j = i;
?int &k = j;
?k++;
?cout<<i<<endl<<j<<endl<<k<<endl;
输出结果为：
6
6
6

28.关于C++调用函数的传值过程：
int f(int x,char c);
int g = f(a,b);
对应的伪汇编：
push b??;这是在进行值拷贝，相当于创建新对象作为函数参数
push a??;c/c++中，参数是从右向左进栈的
call f()?
add sp,4?;这句也是由函数调用产生的，调用代码负责清理栈中的参数
move g,register a?;返回函数结果
;如果a,b,g是全局变量，将被表示成_a,_b,_g，如果是局部变量，编译器将在堆栈指针上对
;其索引。
;通过传值方式传递参数时，编译器简单地将参数拷贝压栈――编译器知道拷贝有多大。
PS：push a ;c/c++中，参数是从右向左进栈的
不尽然，调用约定决定了一切。_stdcall,_cdel,_thiscall,_fastcall，规定了参数的入栈顺序，又由谁(调用者还是被调者)来清理(调整)堆栈，_thiscall还会先把this入栈，因为代码都是全局的，通过this区分某个类的成员/函数。另：这些约定是给编译器看的，告诉它如何生成那些”附加”的代码。http://www.dutor.net/index.php/2009/07/function-call-protocal/

29.不能用const对象来初始化non-const引用，因为引用是直接对所引用存储单元进行操作的，c++出于安全考虑进行此项检查。用const对象初始化const引用或用non-const对象初始化const引用都没有问题。后一种情况（用non-const对象初始化const引用），仍然可以直接更改原对象的值，但不能通过const引用更改。
由此可合理推出，int& i =12;的写法是非法的，因为这试图用一个const对象初始化一个非const引用。

30.调用函数时，如果传递参数和返回函数结果都采用值传递的方式，那么在传递和返回时编译器会自动调用拷贝构造函数来生成局部形参对象和返回结果对象。如果怕编译器提供的拷贝构造函数不能完成拷贝的任务（bitcopy方式），可以自己定义拷贝构造函数。如何避免拷贝构造函数被调用呢？或者说如何避免一个类的对象被按值传递呢？方法是定义一个私有的拷贝构造函数，这样不但屏蔽了编译器的构造函数，而且编译器调用它时会报错。

1.在静态存储区，存储空间在程序运行之前就可以被分配，生命周期持续到程序结束之前。

2.进入一个左大括号，将所有此作用域内的对象的内存在栈上分配，出此右大括号时释放。

3.在程序运行时在堆上动态分配内存，用new操作符，在堆上分配的内存需要程序员负责释放，用delete操作符。如果仍然使用C库中的malloc()（及其变种）和free()，那么构造函数和析构函数得不到机会被执行。C++的做法是将malloc()、free()以及对构造函数、析构函数的调用等等一系列动作封装成两个操作符：new，delete。

new在堆上申请一块内存，并将其作为一个对象调用构造函数进行初始化，然后返回其地址（即指针）： int *p = new int(2); 因为new要调用构造函数，自然就要接受构造函数所需的参数。 delete负责调用欲释放对象的构造函数，然后释放这块内存将其还给堆：

delete p;

如果用new在堆上创建了一个对象，然后通过一个void指针去对其执行delete，那么仅仅会释放内存而不会调用析构函数。用于数组的new和delete

MyType* fp = new MyType[100]; MyType* fp2 = new MyType; //分别在堆上创建了一个数组和一个对象
delete fp; //Not the desired effect
delete fp2; //OK

//因为new的时候返回的都是MyType*，这两个语句效果相同，都只调用了一个对象的构造函数，即对于fp，另外99个对象没有被析构，但是释放的内存大小却是正确的，因为这块内存是连续分配的，而大小被分配机制存储在程序某处。要做到正确的delete一个数组，应该告诉编译器这个指针指向的是一个数组： delete []fp; 这样编译器知道这是一个数组后会查找数组大小，然后进行正确的动作。原始的版本是：

delete [100]fp;

当操作符new无法得到足够的内存时会发生什么呢？会有一个称作new-handle的函数被调用，此函数的缺省动作是抛出一个异常。我们可以用自己写的函数替换它，方法是：包含new.h头文件；写一个自己的new-handle函数，名字不限，必须返回void，且无参数；以函数地址为参数调用set_new_handle()函数，完成替换。

new和delete这两个操作符也是可以重载的，用于自定义动态分配内存时的动作，然而虽然new和delete除了分配内存释放内存外还会调用构造函数和析构函数，但是用户能够自定义的只是操作内存的部分。可以重载全局的new和delete，也可以重载成员的new和delete。全局操作符重载方法：

void* operator new(size_t sz)
{
//…
}

void operator delete(void* m)
{
//…
}

重载全局版本的new和delete运算符会导致所有类型的动态分配和销毁都调用重载版本的new和delete。如果只想作用于特殊类型，则应该只重载成员操作符，方法：

void* MyType::operator new(size_t sz)
{
.
} 
void MyType::operator delete(void* m) 
{
 //…
}

 为一个类重载了new和delete后，任何是否在堆上创建一个此类的对象都会调用该new版本，此内存的释放也一定会使用该delete版本。然而，如果在堆上分配和释放该类的一个数组，则仍然会调用全局版本的new和delete，屏蔽方法是提供数组版本的new和delete运算符：

void* MyType::operator new[](size_t sz) {

}

void MyType::operator delete[](void* m)
{

}

?关于构造函数的调用：完全版本的new的工作是分配内存，返回void*指针（因为目前这只是一块内存，还无所谓类型，所以是void*，待构造函数被调用后才成为一个对象），然后调用构造函数。然而，如果内存分配失败，即返回0，那么构造函数是不会被调用的。改变new的参数表：当我们重载new时，是可以改变其参数表的，原本new只有一个size_t参数，且在调用的时候无需指定，由编译器计算并传递，我们也可以提供第二个、第三个等等参数，然后由程序员在调用new的时候负责传递。

如：

void* MyType::operator new(size_t sz,void* loc)
{
     return loc;
}

//use:

int* l = new int[10];

MyType* pmt = new(l) MyType;

这个重载版本显示了这种改变new参数表技术的一个应用，即指定我们希望被分配的内存地址。

由于编译器的工作是将C代码翻译成汇编指令（从汇编指令生成.o\.obj的二进制可重定位目标文件是汇编器的工作），所以这些优化规则相当于编译器翻译时的辞典。

1.if

if 结构用 test\cmp\jx 来实现。这个很简单，test和cmp能进行类似对条件表达式求值的操作，然后将求值结果用标志位表示，jmp的各种变种可以用标志为指导跳转，从而完成条件转移的功能。

2.循环

循环实际上就是带有条件转移的迭代，每执行一次循环体对条件表达式求值，来决定是继续迭代还是退出循环。所以可以用if\goto的组合来完成和循环一样的控制功能。实际上用for\while\do-while等循环编写出的C源程序与用同样功能的if\goto编写出的C源程序在汇编后得到的代码是相同的。

编译器在翻译循环时，将while和for都翻译成do-while的形式，因为除了第一次迭代以外，while\for和do-while的行为是一致的，而do-while每次循环只需进行一次判断――是否退出循环；而while\for为了要兼容第一次迭代的情况，每次循环要进行两次判断――是否进行循环、是否退出循环。所以，在编译for\while循环时，编译器采取这样的编译策略：在进入循环前先判断第一次循环是否能进行，如果不能进行，跳过循环代码，如果第一次循环能够执行，那接下来的行为就和do-while一致了，便用循环中少一次跳转判断的do-while结构代替之。

3.开关switch

使用跳转表。

一、内联函数如何起作用：
对于普通函数，编译器只把函数名称（对于C++来说也包含了参数类型？）和返回值记录在符号表里，对于内联函数除此之外还在符号表里记录其函数体（究竟存放源代码还是编译后的汇编指令就看编译器的实现了）。当遇到内联函数的调用时，编译器首先检查调用是否正确（参数类型检查，返回结果是否被正确使用――对于普通函数也进行这些检查），检查无误后将内联函数的函数体替换掉对它的调用，从而省去调用函数的开销（参数入栈，汇编CALL等）。

二、如何让函数成为内联：
使用关键字inline指定函数为内联。
声明函数为内联是没有意义也没有必要的，要让函数成为内联需要在定义时指定。
对于类的成员函数有一些特殊，在类的声明内定义的成员函数自动成为内联，在类体外定义的函数就需要显式指定了。
由于内联函数的定义必须被包含在每一个使用它的文件里，而定义的不统一又会造成多重定义的error，因此将内联函数的定义放在头文件里是合适的。
将内联函数的定义放在头文件里的根本原因是，大多数建制环境都是在编译期执行内联的，而编译期要将函数调用替代为函数体，就需要指导函数长什么样。
――>扩展：
这点也和function template相同，函数模板也通常放在头文件里。这是因为大多数编译器在编译期进行函数模板的具现化，因此它需要知道函数模板长什么样子。
所以不应该有“函数模板都是inline”的推论。

三、编译器和内联函数：
有几种情况编译器无法执行函数的内联，遇到这种情况，即使你将函数定义为内联，编译器仍然会将其按照普通函数处理――为函数体分配存储空间。如果这必须在多个编译单元之间进行，这很可能导致多重定义错误，若一定要执行的话（取决于编译器），链接器会被告知忽略多重定义。下面列出这些情况：
1）函数过于复杂。这取决于编译器，但大多数编译器都会选择放弃，这时候即使内联你也得不到任何显著的效率提升。一般，函数体内带有循环或者递归，都会被认为过于复杂。
2）函数被取址时。这就迫使编译器不得不为其分配内存从而产生一个地址，然而在不被取址的地方，内联仍有可能被执行。
另外，对virtual函数的调用也做不到inlining，因为virtual意味着“等待，直到运行期才知道调用哪个函数”，因此编译器无法知道调用的具体函数，也就没法进行代码替换。
一个不应存在的顾虑：
由于类的声明中给出函数的定义时，可能类的全部成员函数没有都完成声明，所以可能会有这样的顾虑：

class A{
    int i;
public:
    A() :i(0){}
    int f() const { return g() + 1; }
    int g() const { return i; }
};

main()
{
    A a;
    a.f();
}

f()定义内调用了g()，而此时g()还没有声明。
其实这种顾虑是不必要的，因为语言定义规定在类中所有内联函数的评估都要在类声明完成时进行。

四、何时使用内联：
内联肯定会提高程序的效率，尽管有时这种提高微乎其微。
内联不一定会带来代码膨胀，如果函数体十分短小，甚至比调用函数所生成的代码都小，那就不会代码膨胀，反而会缩小object code。
这给何时使用内联提供了指导。
inline还有另一个需要考虑的成本：
对于程序开发者，升级一个inline的函数比升级一个outline的函数成本更大，因为inline函数定义在头文件中，因此更新后所有使用到此函数的客户文件都需要重新编译，而对于outline函数，则只需要重新链接即可。如果是动态链接，甚至没有成本。

――The End
后记：

二、const与指针搭配使用
两种使用方式：使指针所指之物为const；使指针所存地址为const。
Pointer to const
如果想让指针所指之物为常量，而指针所含地址可以更改，在定义时将const写在*的左面。然而，这只是说不能通过指针更改其所指之物，此被指之物本身不必是const，也就是不通过指针还是可以更改的。又由于指针本身并不是const，所以定义指针时不必初始化。两种定义格式完全相等，如下：
const int* pi;
int const* pi;
const pointer
如果想让指针为const，即指针不能再指向其它之物，而指针所指之物可以被更改，当然也可以通过指针被更改，那么应将const写在*右面，由于指针是const的，所以定义时必须初始化，如下：
int d = 1;
int* const pi = &d;
也可以让指针同时具有两种属性，还是两种等价的定义格式：
int d = 1;
const int* const p1 = &d;
int const* const p2 = &d;
这样，指针和所指之物就都是const的了。仍然不需要所指之物本身是const的。
可以用non-const之物的地址给指向const之物的指针赋值，不可以把const之物的地址赋给指向non-const之物的指针，除非使用强制转换，那就破坏了const带来的常量性。
关于指向字符串字面值的指针
虽然指向字符串字面值的指针不必是pointer to const，但是字符串字面值是编译器创建的且不容许更改的，因此若通过non-const指针更改其内容，虽无任何编译链接错误，却会导致运行期错误。如下：
char* p = “string”;?//可以通过编译，但技术上是错误的
*p = ‘a’;??//可以通过编译，但会引起运行期错误，实际上是未定义行为，有些机器上也会可以工作
编译器之所以允许non-const指针用字符串字面值初始化，是向大多数依赖于此的C代码的妥协。
要相对字符串字面值作出更改，请使用数组：
char p[] = “string”;

三、用于函数参数和返回值
如果以pass-by-value方式传递函数参数，那么将其声明为const对客户来说毫无意义，参数在函数内部本身就是一个临时对象，它是否改变不影响客户手里的参数原本，因此这个promise毫无意义。所以，这样做是对函数编写者的限制，而不是调用者。为了不迷惑调用者，可以把const的声明从参数列表挪到函数体内，用reference实现：
void f(int i)
{
?const int& j = i;
?j++;?//Illegal — compile-time error
}
对于pass-by-value的函数返回值，存在同样的问题，当写：
const int f();
只是保证函数体内的原返回值不被改变，由于是按照pass-by-value返回的，所以这种保证毫无意义而只会让客户迷惑。
当处理以pass-by-value返回用户自定义类型的函数时，const才显得重要。
对于内置类型的pass-by-value返回的函数，编译器阻止函数调用结果作为左值，而对于用户自定义类型，编译器不做此组织行为，除非将返回值声明为const。用const修饰返回值从而阻止用户自定义类型的返回值作为左值，可以避免if(f()=a)这样的错误（本想做比较而不是赋值）。

如果以指针和引用作为函数参数，那么const参数比non-const参数版本的函数更具一般性：
即可以将non-const指针和变量传递给const参数的函数，反之则不可。
对于临时变量，可以将其传递给接受const引用的函数，而不能传递给接收non-const引用的函数，因为对临时变量的更改是不允许的。
临时变量是不能被取值用于指针传递的。

四、类中的使用
1）类中的编译期常量
首先，不能在类的定义里简单地使用const作为编译期常量定义数组大小了，因为const在每个对象中都会被分配内存，所以编译器在编译期间不知道它的值，这里的“const”只保证在此对象的生命期内该成员不被改变，而不能保证各个对象之间的const成员一致，也就不是编译期常量。
用于产生可以在类中可以使用的编译期常量，有两种方法：
1.使用enum：
enum {size = 10};
int buf[size];
枚举的所有值必须在编译期建立，且不会占用对象中的存储空间，枚举常量在编译期被全部求值。
2.使用static const：
classicA{
private:
?static const int size = 5;
?int buf[size];
};
由于这是类的定义，所以这仅仅是size的声明而非定义。
通常C++要求使用到的东西都有一份定义，但是如果是类中的专属常量，又是static且为整数类型（int,char,bool），则需特殊处理。只要不对其取地址就可以只提供声明而不需定义就能使用。
如果不得不定义，由于声明中已经给了初值，定义中不再需要初值，定义应放在.cpp中而非.h。

2）类中的const成员
如果一个类中有const成员，由于const变量必须在定义时被初始化，所以需要特殊处理：
首先const变量的定义及初始化肯定要发生在类的构造函数里，但是又不能到进入构造函数体内再进行，因为在进入构造函数体内之前，构造函数会调用类中各成员的构造函数来定义各个成员，成员真正的定义时刻发生在此时，构造函数体内发生的是赋值而非初始化。所以正确的做法是在构造函数的初始化列表里提供const成员的初值，用来指导对const变量构造函数的调用。

3）const对象与const成员函数
类和其它内置类型一样，可以声明const的对象。然而对于类这样复杂的类型，编译器如何保证其const性呢？
编译器的做法是只允许const对象调用被声明为const的成员函数，然后再对const成员函数的行为进行限制，从而保证对象的常量性。
声明一个成员函数为const的语法是在函数声明的末尾加上const：
int f() const;
定义时仍要重复此写法否则编译器不将其作为同一个函数。
int A::f() const{
?//do something…
}
构造函数和析构函数都肯定不是const的，因为它们的工作不可避免要更改对象。
const对象只能调用const成员函数，non-const对象则无限制。
如在一个const函数里，想做更改对象的事，怎么办？
还是有办法的：
1.强制转换：在函数内取this指针，这时它是const指针，将其强制转换成non-const指针，即可利用它进行有关操作，编译器不再保护此指针对应的对象的const性：
void Y::f() const{
?((Y*)this)->j++;
}
2.使用关键字mutable，讲一个成员声明为mutable，说明它在const函数中可被改变而不影响对象的常量性。而且可以让用户心中有数。

妨碍编译器进行大胆优化的障碍有这么两个：存储器别名、函数副作用。

对于略显重复的指针解引用运算，编译器是很想将其合并的，但是它又害怕这样的风险――万一两个指针值相同一块内存――即“存储器别名”――如若这样，就会使优化后的程序产生不同的行为，违反了优化的前提。

对于同一个函数的重复调用，编译器也很想用依次调用的翻倍效果来替代，因为函数调用是一项开销很大的工作。但是它同样考虑到这样一种风险――如果这个函数有“副作用”――比如会改变某个全局变量，那么不同次数的调用又会产生行为的差异，同样违反了优化的前提。

以循环程序为例，程序员应做到的优化工作包括：

1.降低循环的低效率

我经常写这样的代码：

for (string::iterator it = str.begin();it != str.end();it++)
//

这就是一个存在低效率的循环。由于for()的第二个测试语句每次迭代都会执行，所以str.end()每次都会被调用，而这个函数的结果在循环过程中是不变的，这就造成了很大的不必要的函数调用开销。此为一。

2.减少函数调用

如前所述，函数调用开销很大，如果循环体内有函数调用，则应考虑是否能将其转换为其它操作，不过这一条对代码行为的依赖性较大，不宜强求。

3.消除不必要的存储器引用

存储是一个金字塔型的结构，越往上速度越快，越往下速度越慢。顶端是寄存器，速度最快。如果循环内部有频繁的写内存动作，应考虑用写寄存器代替之。有些运算――如求阶乘、求数组和等――不需要时时用每次循环的中间结果更新存储器中的目的操作数，在整个求解过程结束后再更新也不迟，这就是用寄存器代替存储器的绝好条件。方法是用一个局部变量代替指针引用，在循环推出后再用局部变量更新指针引用。注意，通常说局部变量在栈上分配，但是这是有条件的，首选是寄存器分配：1.寄存器溢出即寄存器不够用的情况；2.一个要对其产生指针的局部变量必须放在栈上。

另外还有一些比较有意思的技术可以优化程序的性能。

4.循环展开技术（loop unrolling）

对于传统的循环控制来说，每次循环执行一次单位操作，即一次迭代的代价是一次条件判断和一次跳转。如果在每次循环内执行多次迭代，则可以降低平均到一次迭代所对应的条件判断和跳转的次数。这就是循环展开技术。如下面代码就是数组求和的二次循环展开：

for (int i = 0;i &lt; len;i += 2)
{
    temp += a[i];
    temp += a[i+1];
}

5.利用处理器的并行处理能力

说到这就要说说处理器在执行指令时的抽象模型了。这几天看《深入理解计算机系统》这本书中关于处理器的介绍，真的体会到现代处理器真是一个带有浓厚工程学味道的杰作，里面包含了很多策略方面的东西，可谓精打细算。

现代处理器是并行的、乱序的、预测的和投机的。

所谓并行是说，处理器并不像我曾经以为的那样每个时钟周期执行一个基本操作，如此往复。处理器中有众多的处理单元，在一个时钟周期内，每个处理单元都可能进行工作，而实际上只要某个处理单元所作处理的依赖条件已经具备，那么它就可以进行该项处理，即使前面的指令还没有执行完毕，此为“并行”，并行之所以可行，还和“乱序”有关系。

由于处理器是并行工作的，所以每个时钟周期内处理器的正常情景是，能工作的单元一定在工作，分别在执行多条指令的不同部分。而根据程序定义，指令是有顺序的，这里的并行打乱了这种顺序，此为“乱序”。之所以可以乱，是因为超前。一条指令的执行过程往往远早于轮到该指令执行的时间，只要相应处理单元是空闲的即可。到了真该指令执行时，将早已得出的存储在处理器中某个寄存器堆上的结果直接送入目的地即可。这种处理方式在遇到可能发生跳转的地方就会遇到麻烦，现代处理器采用的解决方法是“预测”和“投机”。

处理器会大胆预测跳转的结果，然后继续它的提前化取指、译码、执行；如果预测错误，只得退回预测处重新执行，此为“预测错误处罚”。

现在考虑如何利用处理器的并行工作能力优化程序的性能。如果一次循环操作要依赖于上次循环操作的结果，那么就逼迫操作为线性而难以并行化，所以这种优化只能针对没有这种依赖性的问题上。比如将对数组求和分解成奇数项求和和偶数项求和，最后再相加，而奇数和偶数求和之间是没有依赖性的，所以可以利用上处理器的并行处理能力：

for (int i = 0; i?&lt; len;?i += 2)
{
    x0 += a[i];
    x1 += a[i+1];
}

这段时间分别看了《C++Primer》《Thinking in C++》《Effective C++》三本书关于继承和多态的内容，算是有了一个大概的把握，本想总结的精炼一些，不过现在觉得有点难，暂且记录下学习笔记，待有时间和有能力时，希望自己能把这一块知识好好提炼总结一下，已达到豁然开朗的程度。

学习笔记内容：

面向对象的编程思想有三个基础：
1.封装性：用类实现
2.继承性：用继承实现
3.动态绑定：用虚函数实现
继承性的思想是用旧类创建新类，新类和旧类之间有很大的相似，实现这个思想的一个比较山寨的办法是“组合”。即将旧类的一个对象作为新类的一个成员。
当然比较官方的方法还是“继承”。

《继承》
通过继承我们能够定义这样的类，它们对类型之间的关系建模，共享公共的东西，仅仅特化本质上不同的东西。派生类（derived class）能够继承基类（base class）定义的成员，派生类可以无须改变而使用那些与派生类型具体特性不相关的操作，派生类可以重定义那些与派生类型相关的成员函数，将函数特化，考虑派生类型的特性。最后，除了从基类继承的成员之外，派生类还可以定义更多的成员。
C++中，基类用virtual关键字指明那些它希望派生类重新定义的函数，希望派生类继承的函数不能定义为virtual。除了构造函数以外，任意non-static函数都可以定义为virtual。virtual关键字只用在声明处，不用在定义处。

《动态绑定》
动态绑定允许我们编写这样的程序，对于继承层次中的任意类型的对象都可以使用，无需关系对象的具体类型，无需区分函数是在基类还是在派生类中定义的。
在C++中，通过基类的引用（或指针）调用虚函数时，发生动态绑定。实现动态绑定的关键是：基类的引用和指针既可以指向基类对象也可以指向派生类对象。究竟调用哪个类的虚函数，取决于运行时该引用（或指针）指向的对象的类型。

《如何定义基类》
基类的析构函数一般应定义为virtual。
《？》基类通常应该将派生类需要重定义的任意函数定义为虚函数，why？
对于public和private成员来说，派生类访问基类成员的权限和程序其它部分一样：可以访问public成员，不能访问private成员。
注意，甚至连派生类对象本身也不能访问基类的private成员，在这一点上，派生类和基类的普通用户没有区别。派生类的优势仅体现在protected上。对于基类希望派生类可以访问，但不希望其它代码访问的成员，应定义为protected，protected成员可以被派生类对象访问而不能被普通用户访问。

《protected成员》
派生类可以访问基类的protected对象的意思是，对于派生类对象，其从基类继承来的protected对象是可用的，而对于基类对象的protected对象，派生类仍然没有访问权。例程：
#include <iostream>
using namespace std;

class base_class
{
private:
?int i;
protected:
?int j;
};

class derived_class : base_class
{
public:
?void fun(base_class &bc,derived_class &dc)
?{
??cout<<i<<endl;??//error!base_class::i is private
??cout<<j<<endl;
??cout<<dc.j<<endl;
??cout<<bc.j<<endl;??//error!base_class::j is protected
?}
};
如果没有继承机制，类的用户就只有两种：类本身和类的客户，public和private两种访问限制体现了这两种用户之间的分隔。有了继承机制后，类有了第三种用户――派生类。应该将派生类实现操作所需要访问而不希望普通用户访问的成员定义为protected。
基类的public成员相当于派生类的public成员；基类的protected成员相当于派生类的private成员；基类的private成员对于派生类来说相当于一个与自己无关的类的private，可以使用基类提供的public接口访问它，除此别无他法。

《派生类》
定义派生类的语法为：
class classname: access-label base-class
access-label可以为public，protected，private。表示三种派生方式。有什么区别呢？

《派生方式》
从基类继承来的成员的访问级别由基类的访问标号和派生方式共同控制。派生类可以通过派生方式进一步控制但不能放松继承来的成员的访问级别。
对于基类的private成员，派生类无法访问，因此派生标号控制的是基类的public和protected成员的访问级别。又，对于派生类来说，从基类继承来的public成员和protected成员都是可以访问的，因此，实际控制的是这些继承来的成员作为派生类自己的成员时在派生类中的访问级别属性，即实际控制的是派生类的用户（包括派生类的子类）。
若是public继承，则基类成员在派生类中保持原有访问级别。public还是public，protected还是prptected。
若是protected继承，则基类中的public和protected都是protected。
若是private继承，则基类中的public和protected都是private。
public继承称为接口继承，派生类继承了基类的接口，因此任何使用基类对象的地方，理论上都可以用派生类对象代替。
protected和private继承称为实现继承，它们继承基类的接口不作为自己的接口，而是用来作为自己的实现。
类是使用接口继承还是实现继承对派生类的用户具有重要意义，迄今为止最常见的继承形式是public。
这种限制也是可以改变的，方法是在派生类的定义中在不同的访问控制标号后面使用using声明。
如果在继承的时候不指明派生方式，那么struct默认为public，class默认为private。
一种形象的说明：
public继承相当于昭告天下，D类是从B类派生而来，编译器是知道的。
protected继承是只有自己和自己的派生类知道，即只有D类和D类的派生类知道D类是从B类派生而来。
private继承则只有自己知道。

派生类继承基类的成员并且可以定义自己的附加成员。派生类对象包含两个部分：从基类继承的成员和自己定义的成员。派生类只重定义那些与基类不同或对基类进行扩展的方面。

《重定义成员函数》
实际上派生类可以重定义基类的任何成员，但是只有重定义virtual函数才能实现动态绑定。

《动态绑定》
动态绑定就是父类接口可以接受子类对象，执行哪个版本取决于父类接口（指针和引用）在运行时接受了父类对象还是派生类对象。只有virtual成员可以做到这点。
例程：
base_class bc;
derived_class dc;
base_class* pbc;
int i;
cin>>i;
if(i==0)
?pbc = &bc;
else
?pbc = &dc;
pbc->f();
如果f()是基类的虚函数，而且派生类中重定义了这个函数，那么pbc->f()执行哪个函数就取决于i的输入了。如果f()不是基类的虚函数，即使派生类中重定义了这个函数，pbc->f()也只可能执行基类的版本。这就是virtual关键字对于动态绑定的意义。因为非虚函数的调用是在编译期确定的，pbc是基类指针，只能调用基类的非虚成员函数。
动态绑定可以显式阻止，利用作用域说明符限定虚函数的版本，可以让虚函数的调用在编译期就确定下来。这一技术只能在成员函数的代码中使用。这一技术的一个用途是：可能派生类重定义的基类虚函数需要完成和基类虚函数一样的工作，然后再完成其它工作，这是可以的显式调用基类的虚函数来完成这些工作而避免将基类虚函数的代码拷贝过来。
基类的指针和引用可以指向派生类的对象，但是只能通过此指针或引用调用基类有的成员。因此，使用基类指针和引用时不能确定所引用的对象类型是基类还是派生类，编译器一致当做基类对象处理，将派生类对象作为基类对象处理是安全的，因为派生类对象含有基类对象的子对象。
动态绑定的实现依仗虚指针和虚函数表。

《派生类中虚函数的声明》
派生类中虚函数的声明必须与基类中的定义方式完全相同，除了一个特例：基类中的虚函数如果返回基类对象的引用和指针，派生类中的声明可以返回基类对象的引用或指针，也可以返回派生类对象的引用和指针。

《基类类型和派生类类型之间的转换》
1.概述
对于指针和引用来说，可以进行派生类到基类的自动转换，而没有基类到派生类之间的自动转换。但对于对象来说，编译器不会自动将派生类对象转换为基类类型的对象，虽然我们可以用一个派生类的对象给一个基类对象初始化或赋值。
2.引用转换不同于对象转换
设想一个接受基类引用的函数，如果传递给它一个派生类的对象，这里发生的仅仅是一个绑定，将一个基类引用绑定到一个派生类对象上，派生类对象仍然是派生类类型的，没有改变。
如果这个函数接受的是基类对象而非引用，再传递给它一个派生类对象，则该派生类的基类部分会被拷贝给形参。
后者是用派生类对象给基类对象初始化或赋值，实际上是调用函数――构造函数和赋值操作符。因为基类的拷贝构造函数和赋值操作符都以基类对象的引用为参数，而派生类对象的引用是可以自动转换为基类对象的引用的，因此，用派生类对象给基类对象初始化和赋值是可以实现的。
也就是说，当需要将一个派生类对象转换为一个基类对象时，实际发生的是：
将此派生类对象转换成一个基类对象的引用用来调用拷贝构造函数和赋值操作符，生成一个基类对象。一旦生成，得到的就是基类对象。相当于在初始化和赋值过程中，派生类对象的派生类部分被切掉了。
派生类到基类对象的转换能被那些有访问基类public成员权限的客户访问。派生类本身和其友元肯定可以，至于派生类的普通用户和下层派生类能否访问就要看派生类继承基类时的派生方式了。
3.基类到派生类的转换
没有从基类到派生类自动转换的办法，即使这个基类对象或引用实际绑定了一个派生类对象也不行。如果实际情况中知道这种转换是安全的，可以使用static_cast或者dynamic_cast进行。
《不会自动继承的成员函数》
构造函数、析构函数和operator=不会被自动继承。如果我们自己不在派生类中定义这些成员函数的话，编译器就会用将基类和各成员变量对应的成员函数组合的方式为我们提供这些函数，当然对于构造函数，编译器只能提供缺省构造函数和拷贝构造函数，对于基类中的其它版本，编译器无能为力。同样，编译器也只能通过组合的方式提供作用于相同类型的operator=，而对于基类中的其它版本无能为力。

《构造函数与复制控制》
受继承关系的影响，每个派生类构造函数除了要初始化自己的数据成员外，还要初始化从基类继承来的数据成员。
如果不提供构造函数，编译器同样会提供缺省的构造函数给派生类，与非派生类缺省构造函数不同的是，此缺省构造函数会调用基类的缺省构造函数来初始化基类部分的数据成员。
如果自定义派生类的缺省构造函数，并且在构造函数定义内没有对基类部分的对象进行初始化动作，那么调用此构造函数仍然会自动调用基类的构造函数来初始化基类部分的数据成员。
可以在派生类构造函数的定义中为基类构造函数传递实参，做这项工作需要在初始化列表中完成，而不能直接在函数体内完成。
如果派生类要定义自己的拷贝构造函数，它最好（在初始化列表中）显式地调用基类的拷贝构造函数。可以为基类的拷贝构造函数传递派生类拷贝构造函数收到的派生类对象引用作为参数，它会自动被转换成一个基类对象引用用以调用基类的拷贝构造函数。如果不显式调用基类的拷贝构造函数，基类的缺省构造函数将被调用，产生奇怪的效果：新构造出的派生类对象的基类部分是缺省初始化的，而其它部分却是拷贝初始化的。
同样，派生类的operator=也应如此定义。
析构函数则只需要负责自己的部分，编译器会保证所有层次的析构函数被调用。

《为什么基类的析构函数应该是虚函数？》
因为一个基类指针可以指向基类对象也可以指向派生类对象。而销毁这个指针的动作会导致该指针静态类型的析构函数被调用。如果该指针的静态类型与动态类型不符，那么就会导致未定义行为。即，销毁一个指向派生类对象的基类指针，导致调用基类析构函数去析构一个派生类对象这样的未定义行为。
因此，基类的析构函数应该定义为虚函数，这样在销毁基类指针时，调用哪个析构函数可以根据指针的动态类型来确定。

《函数调用所遵循的四个步骤》
1.首先确定进行函数调用的对象、引用或指针的静态类型。
2.在该类中查找函数，如果找不到，就在直接基类中查找，如此循着类的继承链往上找，直到找到该函数或者查找完最后一个类。如果不能在类或其相关基类中找到该名字，则调用是错误的。
3.一旦找到了该名字，就进行常规类型检查，查看根据找到的定义，该函数调用是否合法。
4.假定函数调用合法，编译器就生成代码。如果函数是虚函数且通过引用或指针调用，则编译器生成代码以确定根据对象的动态类型运行哪个函数版本，否则，编译器生成代码直接调用函数。

《纯虚函数》
可能我们会想定义这么一个类，只希望其它类从它继承，而不希望实例化该类的任何对象，那么应该将它定义为一个抽象基类。
含有或继承（即没有重新定义）一个或多个纯虚函数的类叫做抽象基类，抽象基类无法实例化。
纯虚函数的定义方式是在参数列表后面直接写“=0”：
double net_price(std::size_t) const = 0;
单纯继承抽象基类得到的仍然是抽象基类，只有将所有纯虚函数重新定义后才不是抽象基类。
当定义一个纯虚函数时，相当于告诉编译器在虚函数表中为该函数留一个位置而不保存任何地址，这样就得到一个有不完整虚函数表的类，这种类就是抽象基类。对于虚函数表不完整的类，编译器阻止它实例化。同样还会阻止可能发生的对象切片使抽象积累的对象被按值传递到函数内部。
纯虚函数也是可以给出定义的，直接给出函数体即可。允许这样做的目的是，也许各个派生类中对该纯虚函数的覆盖都会用到同一段代码，这样可以将这段代码作为基类中该纯虚函数的定义，然后在各个覆盖版本中显式调用它即可。

《向上映射》
可以将基类的指针和引用绑定到派生类对象上，但是要求派生方式为public，否则无法绑定，例程：
class A{};
class B:public A{};
class C:protected A{};
class D:private A{};

void fun(A&){}

int main()
{
?B b;
?C c;
?D d;
?fun(b);??//ok
?//fun(c);?//!error
?//fun(d);?//!error
?A* pa;
?pa = &b;?//ok
?//pa = &c;?//!error
?//pa = &d;?//!error
}
为什么？

《C++如何实现晚捆绑》
对于每一个有虚函数的类，编译器为它维护一个单独的虚函数表，称为VTABLE，不管该类实例化了多少个对象，虚函数表都只有一个，虚函数表里存放的是该类所有的虚函数的地址。对于有虚函数的类的对象，编译器在对象结构中（通常是开头）秘密插入一个指针，称为虚指针――VPTR，因此其它结构两个相同的类，一个含有虚函数，一个不含虚函数，那么后者的sizeof比前者大4个字节――一个void*指针的大小。此虚指针存储的是该对象对应的类的虚函数表。当利用基类的地址或引用绑定某基类或派生类对象而调用虚函数时，编译器查看该对象的虚指针，从而得到该对象的类型（实际是得到虚函数表的位置），从而在函数调用的地方插入虚函数表和相对位置来定位要调用的函数（非虚函数的调用是直接插入对函数的汇编CALL的），完成函数调用的晚绑定。
在一个派生体系中，各个类的虚函数表中各函数指针的相对顺序是固定的，父类虚函数在前，子类新增的虚函数在后。
在调用任何虚函数之前安装虚函数表指针是很重要的，安装VPTR的工作在构造函数中进行。

《构造函数和虚指针》
构造函数是安装虚指针的地方，而对于派生体系中的一个对象而言，它的初始化会导致该体系中从根到它所在层次的所有相关构造函数都被调用，而每个构造函数都会做一次初始化虚指针的工作，将该对象虚指针指向该构造函数所在类的虚函数表，而下一层次的构造函数会再次给虚指针赋值以覆盖它为当前类的虚函数表，因此，该对象的VPTR状态是由最后被调用的构造函数所确定的。
在一个个构造函数被依次调用的过程中，VPTR始终指向的是此构造函数对应类的VTABLE，因此在构造函数中调用虚函数，将屏蔽虚机制而直接调用本地版本。
实际上，析构函数中也屏蔽虚机制，调用虚函数的本地版本。
构造函数和析构函数中，虚机制被屏蔽的另一个容易理解的原因是，在构造函数和析构函数被调用的过程中，对象是不完整的，可能虚机制会导致虚函数操作还未产生的成员。
《对象切片》
按传值的方式将派生类对象传递给基类对象的形参，会发生对象切片，对象切片是安全的，得到的是地地道道的基类对象，无论数据成员还是成员函数都是基类的。因为按值传递时会调用拷贝构造函数，所以切片得到的基类对象有机会在拷贝构造函数中将自己的VPTR设置为正确地指向基类的VTABLE。

《Notes》
1.基类必须是定义过的类，而不能是只声明过的类。
2.派生类可以做基类继续被其它派生类继承。
3.如果只声明派生类而不定义它，那么不能写出派生列表。
4.虚函数也可以有默认实参，但是需要注意的是，如果使用指针或引用来调用虚函数，默认实参所取的值与指针和引用类型相关，而不取决于动态绑定时实际绑定的对象类型。
5.友元属性不能被继承，基类的友元不是派生类的友元；基类是友元，派生类也不会成为友元。
6.即使被继承，在继承层次中，static成员仍然只有一份实例。访问控制同普通成员。
7.一旦你开始定义派生类的拷贝构造函数和operator=，编译器就假定你知道自己在做什么，就不会再为你自动调用基类版本的拷贝构造函数和operator=了，而如果你不定义派生类的拷贝构造函数和operator=的话，编译器是会在提供组合版本时为你调用的。因此，定义派生类的拷贝构造函数和operator=时，应显式地调用基类的拷贝构造函数和operator=，否则将默认调用基类的缺省构造函数，而基类的operator=将不会被调用。
8.static成员函数不能为virtual。
9.派生类的构造函数只能初始化自己的直接基类。
10.派生类构造函数不能初始化基类的成员且不应该对基类成员赋值。如果那些成员为 public 或 protected，派生构造函数可以在构造函数函数体中给基类成员赋值，但是，这样做会违反基类的接口。派生类应通过使用基类构造函数尊重基类的初始化意图，而不是在派生类构造函数函数体中对这些成员赋值。
11.对于一个指向派生类对象的基类指针：
B* pb = &d;
来说，
pb->f();
会导致多态调用D::f()，然而，如果指定类名：
pb->B::f();
便可以屏蔽多态，调用B::f()。
12.如果D是从B以private方式派生，那么就不能用D对象给B指针或引用赋值，因为D对象中的B部分对于D对象是不可访问的，而如此赋值的目的就是访问这些部分，所以编译器阻止，但如果如下方式赋值：
B* pb = (B*) &d;
就可以，就像B是从D以public方式派生来的一样。
13.由于构造和析构过程中对象类型的不确定性，编译器认为在构造和析构的过程中对象的类型是变化的。如果在构造函数和析构函数内调用虚函数，则虚函数的版本依构造函数和析构函数的类型而定，而不再依据对象的具体类型。
14.基类指针引用虽然可以指向派生类对象，但只能通过它们访问对象的基类部分。对象指针和引用的静态类型决定了对象的行为。
15.派生类的成员名字将屏蔽基类中的成员名字，因为派生类的名字空间嵌套在基类中，编译器先在派生类中查找该名字，一旦找到，就不再继续寻找，如果没找到，再到基类中找。因此，如果基类和派生类都定义了相同名字的成员函数，但是参数表不同。通过派生类对象调用该函数，但是传递符合基类版本的参数的话，会造成错误，因为编译器在派生类中找到同名函数后就不再继续查找了，而这个函数是不能接收基类版本函数的参数的。相似情况也适用于局部作用于中声明的函数和全局作用域中定义的函数之间的关系。
16.如果基类中的成员函数有多个重载版本，那么要想通过派生类类型调用所有这些版本，要么一个都不能重定义，要么就要全部重定义。如果只有一个版本需要重定义，而其它版本想要直接使用基类版本的话，则应该使用using声明说明基类该成员函数所有版本可用（因为using声明不说明参数表），然后重定义所需版本。
17.protected继承只是为了语言的完整性，private继承还有些许功能，最常用的应该是public继承。
18.选择继承还是组合技术的一个重要依据是两者关系是is-a还是has-a，另外，是否需要向上映射。
19.编译器会在构造函数的头部秘密插入能够设置VPTR的代码。
《Effective C++》
《条款32――确定你的public塑模出is-a关系》
public继承应该用在派生类和基类之间存在“is-a”关系的情况。适用于base-classes身上的每一件事情一定也适用于derived-classes身上，因为每个derived class对象也都是一个base class对象。编译器可以完成从派生类对象到基类对象的各种转换（指针，引用，值传递）。
《条款33――避免遮掩继承而来的名称》
通常，在public继承下，应该继承基类的所有成员函数，而不能重定义以对其遮掩，因为这违反public塑模出的is-a关系。但是，在private继承下这是有意义的。这时重新定义基类函数会造成基类中所有版本的函数都被遮掩，要让基类函数在派生类中重见天日，可以使用using声明或者转交函数，在转交函数内部显示调用基类的函数。
《条款34――区分接口继承和实现继承》
public继承表面是is-a的关系，所以在public继承下，派生类总是继承基类的接口，但是基类的成员函数属性的不同，代表了它所希望派生类去继承它的方式。
基类的函数可以有三种属性：
1.non-virtual函数――希望派生类以实现继承的方式继承，即强制性指定了实现方式，不希望派生类对其重新定义――条款33。
2.common-virtual函数――希望派生类继承此接口，并且具体实现，但是提供了一份缺省实现供不需具体实现的派生类使用。
3.pure-virtual函数――只希望派生类继承此接口，具体实现希望派生类自己定义，这类函数显示的是派生类的特性超越继承自基类的共性。
《条款36――绝不重新定义继承而来的non-virtual函数》
原因见条款32、33、34。
《条款37――绝不重新定义继承而来的缺省参数值》
因为我们已经达成共识，不会重新定义继承来的non-virtual函数――条款36，因此这里讨论的就是不要重新定义继承来的virtual函数的缺省参数值。原因很明白，virtual函数实行动态绑定，而缺省参数值却是静态绑定。所以如果重新定义了继承来的virtual函数的缺省参数值的话就可能导致这样的奇怪行为――用基类版本的缺省参数值调用派生类版本的函数。
《条款38――通过复合塑模出has-a或“根据某物实现出”》
复合――即将某类的一个对象作为新类的一个成员。复合技术和继承有些许相似之处，都是用旧类生成新类。前文提到，public继承代表的派生类和基类关系是is-a，而复合代表的新类和旧类关系有两种――has-a（应用域）和“根据某物实现出”（实现域）。比如一个Person有一个PhoneNumber，一个set用一个list实现。