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