声明：本文内容源于Geekband；
一.vptr与vtable
1. vptr每个对象都会有一个，而vtable是每个类有一个
2. vptr指向了vtable
3. 在C++中，如果一个类有虚函数，那么这个对象的memory layout中就有特个vptr，且在最前面
4. 一个类中就算有多个虚函数，也只有一个vptr
5. 做多重继承，就是继承了多个父类时，就会有多个vptr
二、this（比较简单，不谈了）
三、动态绑定
CSDN上有一篇很好的帖子说这个：http://blog.csdn.net/chgaowei/article/details/6427731
一个经典的例子（腾讯笔试题）：
有如下C++代码：
struct A{
voidfoo(){printf("foo");}
virtualvoidbar(){printf("bar");}
A(){bar();}
};
structB:A{
voidfoo(){printf("b_foo");}
voidbar(){printf("b_bar");}
};
那么
A *p=new B;
p->foo();
p->bar();
这个题的结果是barfoob_bar
为什么㖏，我们研究下哈，
首先说明一下，那两各foo（）是非需函数，这是个不好的写法，他在这里只是说明动态绑定这个东西；
首先说一下说明是动态绑定：
动态绑定是指在执行期间（非编译期）判断所引用对象的实际类型，根据其实际的类型调用其相应的方法。
程序运行过程中，把函数（或过程）调用与响应调用所需要的代码相结合的过程称为动态绑定。
动态绑定是将一个过程调用与相应代码链接起来的行为。是指与给定的过程调用相关联的代码，只有在运行期才可知的一种绑定，他是多态实现的具体形式。
以上是百度百科中的 借鉴一下，差不多就是这个意思。
现在我们定一个B* d，这时候d->foo();和p->foo();调动的是同一个函数吗？答案很明显是否定；
这里虽然函数名一样，但已经是静态绑定了，两个类型分别调用自己类内定义的foo（）函数。
这时候在看一下p->bar 这里虽然p是个A型的指针，但是执行代码时涉及到一个动态绑定问题，p的实际类型是个B,所以调用B函数的bar（）而不是A的；
最后总结一句话，只有虚函数才涉及到动态绑定，其他可以说都是静态绑定。
注意：A(){bar();}这里，在构造函数或者析构函数里调用虚函数，此时虚函数不具有多态性。
四、 const
（1）欲阻止一个变量被改变，可以使用const关键字。在定义该const变量时，通常需要对它进行初始化，因为以后就没有机会再去改变它了；
（2）对指针来说，可以指定指针本身为const，也可以指定指针所指的数据为const，或二者同时指定为const；
（3）在一个函数声明中，const可以修饰形参，表明它是一个输入参数，在函数内部不能改变其值；
（4）对于类的成员函数，若指定其为const类型，则表明其是一个常函数，不能修改类的成员变量；
（5）对于类的成员函数，有时候必须指定其返回值为const类型，以使得其返回值不为“左值”。
五、new与delete及其重载
例子：
new、delete（new[]、delete[]）操作符的重载需要注意：
1.重载的 new、delete（或者 new[]、delete[]）操作符必须是类的静态成员函数（为什么必须是静态成员函数，这很好理解，因为 new 操作符被调用的时候，对象还未构建）或者是全局函数，函数的原型如下：
复制代码代码如下:
void* operator new(size_t size) throw(std::bad_alloc);
// 这里的 size 为分配的内存的总大小
void* operator new[](size_t size) throw(std::bad_alloc);
void operator delete(void* p) throw();
void operator delete[](void* p) throw();
void operator delete(void* p, size_t size) throw();
// 区别于 new[] 的参数 size，这里的 size 并非释放的内存的总大小
void operator delete[](void* p, size_t size) throw();
另外，我们可以使用不同的参数来重载 new、delete（或者 new[]、delete[]）操作符，例如：
复制代码代码如下:
// 第一个参数仍为 size_t
void* operator new(size_t size, const char* file, int line);
// 此操作符的使用
string* str = new(__FILE__, __LINE__) string;
重载全局的 new、delete（或者 new[]、delete[]）操作符会改变所有默认分配行为（包括某个类的分配行为），因此必须小心使用，如果两个库都 new 等进行了全局重载，那么就会出现链接错误（duplicated symbol link error）。而在类中定义的 new、delete（或者 new[]、delete[]）操作符只会影响到本类以及派生类。
很多人完全没有意识到 operator new、operator delete、operator new[]、operator delete[] 成员函数会被继承（虽然它们是静态函数）。有些时候，我们只想为指定的类设置自定义的 operator new 成员函数，而不希望影响到子类的工作。《Effective C++ Third Edition》提供了如下的方案：
复制代码代码如下:
void * Base::operator new(std::size_t size) throw(std::bad_alloc)
{
// 如果大小不为基类大小
if (size != sizeof(Base))
// 调用标准的 new 操作符
return ::operator new(size);
自定义大小为基类大小的分配处理
}
这样处理的一个前提是：认为子类的大小一定大于父类。
对于 operator new[] 来说，我们很难通过上面的方式检查到底是父类还是子类调用了操作符。通过 operator new[] 操作符的参数，我们无法得知分配的元素的个数，无法得知分配的每个元素的大小。operator new[] 的参数 size_t 表明的内存分配的大小可能大于需要分配的元素的内存大小之和，因为动态内存分配可能会分配额外的空间来保存数组元素的个数。
2.兼容默认的 new、delete 的错误处理方式
这不是个很简单的事（详细参考《Effective C++ Third Edition》 Item 51）。operator new 通常这样编写：
复制代码代码如下:
// 这里并没有考虑多线程访问的情况
void* operator new(std::size_t size) throw(std::bad_alloc)
{
using namespace std;
// size == 0 时 new 也必须返回一个合法的指针
if (size == 0)
size = 1;
while (true) {
尝试进行内存的分配
if (内存分配成功)
return (成功分配的内存的地址);
// 内存分配失败时，查找当前的 new-handling function
// 因为没有直接获取到 new-handling function 的办法，因此只能这么做
new_handler globalHandler = set_new_handler(0);
set_new_handler(globalHandler);
// 如果存在 new-handling function 则调用
if (globalHandler) (*globalHandler)();
// 不存在 new-handling function 则抛出异常
else throw std::bad_alloc();
}
}
这一些方面是我们需要注意的：operator new 可以接受 size 为 0 的内存分配且返回一个有效的指针；如果存在 new-handling function 那么在内存分配失败时会调用它并且再次尝试内存分配；如果不存在 new-handling function 失败时抛出 bad_alloc 异常。
要注意的是，一旦设置了 new-handling function 内存分配就会无限循环进行下去，为了避免无限循环的发生，new-handling function 必须做以下几件事中的一件（详细参考《Effective C++ Third Edition》 Item 49）：让有更多内存可用、设置另一个能发挥作用的 new-handler、删除当前的 new handler、抛出一个异常（bad_alloc 或者继承于 bad_alloc）、直接调用 abort() 或者 exit() 等函数。
对于 operator delete 的异常处理就简单一些，只需要保证能够安全的 delete 空指针即可：
复制代码代码如下:
void operator delete(void *rawMemory) throw()
{
// 操作符可以接受空指针
if (rawMemory == 0) return;
释放内存
}
多态的问题（详细参考《ISO/IEC 14882》）
前面谈到了 new、delete（new[]、delete[]）操作符的继承，这里额外讨论一下多态的问题，显然我们只需要讨论 delete、delete[] 操作符：
复制代码代码如下:
struct B {
virtual ~B();
void operator delete(void*, size_t);
};
struct D : B {
void operator delete(void*);
};
void f()
{
B* bp = new D;
delete bp; //1: uses D::operator delete(void*)
}
通过上面的例子，我们可以看到，delete 时正确的调用了 D 的 operator delete 操作符。但是同样的，对于 delete[] 操作符工作就不正常了（因为对于 delete[] 操作符的检查是静态的）：
复制代码代码如下:
struct B {
virtual ~B();
void operator delete[](void*, size_t);
};
struct D : B {
void operator delete[](void*, size_t);
};
void f(int i)
{
D* dp = new D[i];
delete [] dp; //uses D::operator delete[](void*, size_t)
B* bp = new D[i];
delete[] bp; //undefined behavior
}