C和C++ 的基本问题

1、pass value.

2、pointer，&，pointer变量

3、堆栈

C++的常用问题：

虚函数，如何实现多态，

new /delete （用户空间）

malloc/free（系统空间），

虚表。

下面转自：http://blog.csdn.net/hackbuteer1/article/details/6789164

相同点：都可用于申请动态内存和释放内存


不同点：


（1）操作对象有所不同。


malloc与free是C++/C语言的标准库函数，new/delete是C++的运算符。对于非内部数据类的对象而言，光用maloc/free无法满足动态对象的要求。对象在创建的同时要自动执行构造函数， 对象消亡之前要自动执行析构函数。由于malloc/free是库函数而不是运算符，不在编译器控制权限之内，不能够把执行构造函数和析构函数的任务强加malloc/free。


（2）用法上也有所不同。


函数malloc 的原型如下：


void * malloc(size_t size);


用malloc 申请一块长度为length 的整数类型的内存，程序如下：


int *p = (int *) malloc(sizeof(int) * length);


我们应当把注意力集中在两个要素上：“类型转换”和“sizeof”。


1、malloc 返回值的类型是void *，所以在调用malloc 时要显式地进行类型转换，将void * 转换成所需要的指针类型。


2、 malloc 函数本身并不识别要申请的内存是什么类型，它只关心内存的总字节数。


函数free 的原型如下：


void free( void * memblock );


为什么free 函数不象malloc 函数那样复杂呢？这是因为指针p 的类型以及它所指的内存的容量事先都是知道的，语句free(p)能正确地释放内存。如果p 是NULL 指针，那么free


对p 无论操作多少次都不会出问题。如果p 不是NULL 指针，那么free 对p连续操作两次就会导致程序运行错误。


new/delete的使用要点：


运算符new使用起来要比函数malloc 简单得多，例如：


int *p1 = (int *)malloc(sizeof(int) * length);


int *p2 = new int[length];


这是因为new 内置了sizeof、类型转换和类型安全检查功能。对于非内部数据类型的对象而言，new 在创建动态对象的同时完成了初始化工作。如果对象有多个构造函数，那么new 的语句也可以有多种形式。


如果用new 创建对象数组，那么只能使用对象的无参数构造函数。例如


Obj *objects = new Obj[100]; // 创建100 个动态对象


不能写成


Obj *objects = new Obj[100](1); // 创建100 个动态对象的同时赋初值1


在用delete 释放对象数组时，留意不要丢了符号‘[]’。例如


delete []objects; // 正确的用法


delete objects; // 错误的用法


后者相当于delete objects[0]，漏掉了另外99 个对象。


///////////////////////////////////////////////////////////////////////////


1、new自动计算需要分配的空间，而malloc需要手工计算字节数


2、new是类型安全的，而malloc不是，比如：


int* p = new float[2]; // 编译时指出错误


int* p = malloc(2*sizeof(float)); // 编译时无法指出错误


new operator 由两步构成，分别是 operator new 和 construct


3、operator new对应于malloc，但operator new可以重载，可以自定义内存分配策略，甚至不做内存分配，甚至分配到非内存设备上。而malloc无能为力


4、new将调用constructor，而malloc不能；delete将调用destructor，而free不能。


5、malloc/free要库文件支持，new/delete则不要。


///////////////////////////////////////////////////////////////////////////


1、本质区别


malloc/free是C/C++语言的标准库函数，new/delete是C++的运算符。


对于用户自定义的对象而言，用maloc/free无法满足动态管理对象的要求。对象在创建的同时要自动执行构造函数，对象在消亡之前要自动执行析构函数。由于malloc/free是库函数而不是运算符，不在编译器控制权限之内，不能够把执行构造函数和析构函数的任务强加于malloc/free。因此C++需要一个能完成动态内存分配和初始化工作的运算符new，以及一个能完成清理与释放内存工作的运算符delete。


class Obj


{


public:


Obj( )


{ cout << "Initialization" << endl; }


~ Obj( )


{ cout << "Destroy" << endl; }


void Initialize( )


{ cout << "Initialization" << endl; }


void Destroy( )


{ cout << "Destroy" << endl; }


}obj;


void UseMallocFree( )


{


Obj * a = (Obj *) malloc( sizeof ( obj ) ); // allocate memory


a -> Initialize(); // initialization


// …


a -> Destroy(); // deconstruction


free(a); // release memory


}


void UseNewDelete( void )


{


Obj * a = new Obj;


// …


delete a;


}


类Obj的函数Initialize实现了构造函数的功能，函数Destroy实现了析构函数的功能。函数UseMallocFree中，由于malloc/free不能执行构造函数与析构函数，必须调用成员函数Initialize和Destroy来完成“构造”与“析构”。所以我们不要用malloc/free来完成动态对象的内存管理，应该用new/delete。由于内部数据类型的“对象”没有构造与析构的过程，对它们而言malloc/free和new/delete是等价的。


2、联系


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

下面转自：http://eriol.iteye.com/blog/1167737

关于虚函数的背景知识

1. 用virtual关键字申明的函数叫做虚函数，虚函数肯定是类的成员函数。
2. 存在虚函数的类都有一个一维的虚函数表叫做虚表。类的对象有一个指向虚表开始的虚指针。虚表是和类对应的，虚表指针是和对象对应的。
3. 多态性是一个接口多种实现，是面向对象的核心。分为类的多态性和函数的多态性。
4. 多态用虚函数来实现，结合动态绑定。
5. 纯虚函数是虚函数再加上= 0。并且该函数只有声明，没有实现。
6. 抽象类是指包括至少一个纯虚函数的类。

 

那虚函数是如何运行的呢？

 

Cpp代码  

1. class Base   
2. {  
3.     public:  
4.         virtual void func() {}  
5. }  
6.   
7. class Derive : public Base  
8. {  
9.     public:  
10.         void func() {}  
11. }  
12.   
13. void main()  
14. {  
15.     Derive d;  
16.     Base *pb = &d;  
17.     b->func();  
18. }  

 

    编译器在编译的时候，发现Base类中有虚函数，此时编译器会为每个包含虚函数的类创建一个虚表（即vtable），该表是一个一维数组，在这个数组中存放每个虚函数的地址。由于Base类和Derive类都包含了一个虚函数func()，编译器会为这两个类都建立一个虚表，（即使子类里面没有virtual函数，但是其父类里面有，所以子类中也有了）

 

    那么如何定位虚表呢？编译器另外还为每个类的对象提供了一个虚表指针（即vptr），这个指针指向了对象所属类的虚表。在程序运行时，根据对象的类型去初始化vptr，从而让vptr正确的指向所属类的虚表。所以在调用虚函数时，就能够找到正确的函数。

 

    对于上述程序，由于pb实际指向的对象类型是Derive，因此vptr指向的Derive类的vtable，当调用pb->func()时，根据虚表中的函数地址找到的就是Derive类的func()函数。

 

    正是由于每个对象调用的虚函数都是通过虚表指针来索引的，也就决定了虚表指针的正确初始化是非常重要的。换句话说，在虚表指针没有正确初始化之前，我们不能够去调用虚函数。那么虚表指针在什么时候，或者说在什么地方初始化呢？

答案是在构造函数中进行虚表的创建和虚表指针的初始化。

 

    还记得构造函数的调用顺序吗，在构造子类对象时，要先调用父类的构造函数，此时编译器只“看到了”父类，并不知道后面是否后还有继承者，它初始化父类对象的虚表指针，该虚表指针指向父类的虚表。当执行子类的构造函数时，子类对象的虚表指针被初始化，指向自身的虚表。对于以上的例子，当Derive类的d对象构造完毕后，其内部的虚表指针也就被初始化为指向Derive类的虚表。在类型转换后，调用pb->func()，由于pb实际指向的是Derive类的对象，该对象内部的虚表指针指向的是Derive类的虚表，因此最终调用的是Derive类的func()函数。

 

    要注意：对于虚函数调用来说，每一个对象内部都有一个虚表指针，该虚表指针被初始化为本类的虚表。所以在程序中，不管你的对象类型如何转换，但该对象内部的虚表指针是固定的，所以呢，才能实现动态的对象函数调用，这就是C++多态性实现的原理。

 

 

总结（基类有虚函数）：

1. 每一个类都有虚表。
2. 虚表可以继承，如果子类没有重写虚函数，那么子类虚表中仍然会有该函数的地址，只不过这个地址指向的是基类的虚函数实现。如果基类有3个虚函数，那么基类的虚表中就有三项（虚函数地址），派生类也会有虚表，至少有三项，如果重写了相应的虚函数，那么虚表中的地址就会改变，指向自身的虚函数实现。如果派生类有自己的虚函数，那么虚表中就会添加该项。
3. 派生类的虚表中虚函数地址的排列顺序和基类的虚表中虚函数地址排列顺序相同。