c++的两大特色是多态和模板。其中多态是通过继承和虚函数来实现的，其中虚函数是通过每个对象里面的虚表来实现的。如果这个对象的类有虚函数，那么这个类就有一张虚表，存的是每个虚函数的入口地址，而这个类的每个对象，都会有一个4字节的指针，指向这张虚表，这个就是虚指针。
上面一段话很多人都知道，但是如果问普通成员函数，编译器是怎么找到它的入口地址的呢？也就是说，怎么进行调用？为什么A类一个foo函数和B类一个foo函数，A类的对象.foo就一定是调用A的foo？有人会说运行时类型识别RTTI。假如识别出A类的对象，那么A类的对象a，和A类的对象b，分别调用foo处理成员变量的时候，为什么不会a调用foo处理的是b的数据？这个问题只要问深几层，RTTI的说法就不攻自破。其实面向对象语言都是用反射，也就是对象把自己的地址作为参数，传入成员函数的this指针，通过this指针来确定数据的。
还记得函数重载的实现机制吧，在c++里面是通过将函数名和函数的参数列表结合来区分不同的函数，同名但不同参数列表的函数，是不同的函数。例如void foo(int,int)在c里面编译器是用_foo来识别，在c++里面是用_foo_int_int来识别。
那么A类的foo函数和B类的foo函数，如果参数列表一致，怎么区分它们呢？用A类的一个对象调用成员函数，这个成员函数用到成员变量，怎么知道是在用这个对象的数据呢？这个解释，就是this指针。A类的foo(int,int)函数，已经被编译器编译成_foo_A*_int_int，也就是说隐含已经加入了函数所属类的信息，调用A类对象a.foo的时候，已经在调用foo(const A * this,int,int)这个函数。这也解释了，为什么在成员函数内部，使用成员变量，有时候(并不是全部情况下都如此)前面加this和不加this没有区别，编译器已经把foo里面用到的成员变量，用this指针指向了。
如果你在全局中，这样定义这样一个函数foo(const A * this,int,int)去模仿成员函数的调用，将不能编译，因为this是关键字，this指针已经成为了c++的机制，在类成员函数用this才做形参(foo(int this)或者foo(float this))，也是非法的。这样试图和编译器生成的函数的第一个参数this来一个重定义。
举个例子，下面一段代码：
1 class A 2 { 3 public: 4 void foo(){ cout << "A foo" << endl; } 5 }； 6 class B 7 { 8 public: 9 void foo(){ cout << "B foo" << endl; } 10 }；
oo将编译成：
1 void foo(const A* this)( cout << "A foo" << endl; } 2 void foo(const B* this)( cout << "B foo" << endl; }
调用a.foo()，编译器将转换成foo(&a)
有趣的是，A* pa = NULL; pa->foo();也没有异常退出，因为没有通过this引用任何成员变量，这个时候不过this指针为NULL而已。
静态成员函数
上面说的只是面向对象的非静态成员函数，如果说到类里面的静态成员函数，解释又是另外一个，请看下文。
1、静态数据成员
特点：
A、内存分配：在程序的全局数据区分配。
B、初始化和定义：
a、静态数据成员定义时要分配空间，所以不能在类声明中定义。
b、为了避免在多个使用该类的源文件中，对其重复定义，所在，不能在类的头文件中
定义。
c、静态数据成员因为程序一开始运行就必需存在，所以其初始化的最佳位置在类的内部实现。
C、特点
a、对相于
public，protected，private 关键字的影响它和普通数据成员一样，
b、因为其空间在全局数据区分配，属于所有本类的对象共享，所以，它不属于特定的类对象，在没产生类对象时其作用域就可见，即在没有产生类的实例时，我们就可以操作它。
D、访问形式
a、 类对象名.静态数据成员名
b、 类类型名:: 静态数据成员名
E、静态数据成员，主要用在类的所有实例都拥有的属性上。比如，对于一个存款类，帐号相对 于每个实例都是不同的，但每个实例的利息是相同的。所以，应该把利息设为存款类的静态数据成员。这有两个好处，第一，不管定义多少个存款类对象，利息数据成员都共享分配在全局区的内存，所以节省存贮空间。第二，一旦利息需要改变时，只要改变一次，则所有存款类对象的利息全改变过来了，因为它们实际上是共用一个东西。
2、静态成员函数
特点：
A、静态成员函数与类相联系，不与类的对象相联系。
B、静态成员函数不能访问非静态数据成员。原因很简单，非静态数据成员属于特定的类实例。
作用：
主要用于对静态数据成员的操作。
调用形式：
A、类对象名.静态成员函数名（）
B、类类型名::
静态成员函数名（）
上面是一段精辟的分析，但是他没有说道编译器是如何实现这个调用的。下面一段代码，将解释这个过程：
1 #include <iostream> 2 using namespace std; 3 4 class A 5 { 6 public: 7 static int count; 8 void foo(){ cout << "A foo" << endl; } // 如果这样声明和定义一个成员函数，将直接产生一个 foo(A& this) 类型的函数 9 static void goo(){ cout <</* this << */"A goo"<< endl; } // 静态函数没有 this 指针 10 void too(){ cout << typeid(*this).name() << endl; } 11 }; 12 13 int A::count = 0; 14 15 class B : public A 16 { 17 public: 18 // 如果静态函数只能通过域运算符来调用的话，那class在静态意义下就成了命名域的概念了 19 // 如果没有下面这个函数，A类的goo函数将会继承下来，说明作为类的命名空间，也可以继承 20 static void goo(){ cout << "B goo" << endl;} // 一个问题，静态的成员函数，是怎么区分开的呢？ 21 }; 22 23 int main() 24 { 25 A a , *pa; 26 pa->goo(); // 静态也跟普通函数一样，没有多态效果 27 a.goo(); // 是否是直接翻译成 A::goo() 竟然说我没引用过 a ！- - 28 // a.foo(); // this 是关键字，不能拿来作为一个全局函数的参数，在转成 foo(&a) 的时候，一定是调用 foo(A& this) 这个函数 29 // A::foo(); // 这个 foo 没有带参数，只能调用静态的，静态的就直接编译成类似全局函数的不带 this 参数的类型 30 A::goo(); // 这样调用是正确的，这说明它没有 this 指针作为形参 31 system("pause"); 32 return 0; 33 }
编译运行，将产生一个警告，说对象a和指针pa从来没引用过！通过对象调用静态函数，已经通过类型识别，被编译器替换成A::goo()，这个是由编译器做的，所以替换之后a就只定义了，但是没用引用过。换句话，static的成员函数，只能通过域运算符来调用，无论你是用对象调用还是用指针调用。
static的成员变量，也是如此，只能通过翻译成域运算符来调用。这样两者结合在一起，说明了“类其实除了可以定义变量，还有一个重要的作用就是它是个命名域，相当于std::cout这样。而且，这个命名域，还能继承下来。”
还记得stl里面的迭代器吗？迭代器的类，就是为了不污染全局空间，把迭代器类声明在某个stl容器类里面。这个类里面的类，只能通过容器和域运算符才可见，有趣的是，这个类中类，也可以继承。
#include <iostream> using namespace std; class A { public: class C{}; // 类中类 }; class B : public A { }; int main() { B::C c; // 除了父类，子类也可见 return 0; }
这里由于某个问题找到了这边博文，感觉不错，转自：http://blog.csdn.net/yuanyirui/article/details/4594805