用类去定义对象时，系统会为每一个对象分配存储空间。如果一个类包括了数据和函数，要分别为数据和函数的代码分配存储空间。按理说，如果用同一个类定义了10个对象，那么就需要分别为10个对象的数据和函数代码分配存储单元。
能否只用一段空间来存放这个共同的函数代码段，在调用各对象的函数时，都去调用这个公用的函数代码。
这里举一个例子来说明：
#include <iostream> using namespace std; class Time { public: int hour; int minute; int sec; void setHour( ) { hour=10; } }; int main( ) { cout<<sizeof(Time)<<endl; return 0; }
程序运行的结果是12
这就说明Time类对象中仅仅包含数据成员部分，而却没有包含成员函数部分。
虽然调用不同对象的成员函数时都是执行同一段函数代码，但是执行结果一般是不相同的。这样，我们很自然地要问，类的成员函数如何区分不同的实例对象的数据成员呢?不同的对象使用的是同一个函数代码段，它怎么能够分别对不同对象中的数据进行操作呢？
原来C++为此专门设立了一个名为this的指针，用来指向不同的对象。一个对象的this指针并不是对象本身的一部分，不会影响sizeof(对象)的结果。
this指针是一个隐含于每一个成员函数中的特殊指针。它是一个指向正在被该成员函数操作的对象，也就是要操作该成员函数的对象。this作用域是在类内部，当对一个对象调用成员函数时，编译程序先将对象的地址赋给this指针，编译器会自动将对象本身的地址作为一个隐含参数传递给函数。也就是说，即使你没有写this指针，编译器在编译的时候也是加上this的，它作为非静态成员函数的隐含形参。被调用的成员函数函数体内所有对类成员的访问，都会被转化为“this->类成员”的方式。
形象地描述就是：一个学生可以有多本书一样，而这些书都是属于这个同学的；同理，如果有很多个同学在一起，那么为了确定他们的书不要拿混淆了，最好的办法我想应该就是每个同学都在自己的书上写上名字，这样肯定就不会拿错了。
同理，一个对象的多个成员就可看作是这个对象所拥有的书；而在很多个对象中间，我们为了证明某个成员是自己的成员，而不是其他对象的成员，我们同样需要给这些成员取上名字。在C++中，我们利用this指针帮助对象做到这一点，this指针记录每个对象的内存地址，然后通过运算符->访问该对象的成员。
关于this指针的一个精典回答:
你可以看见桌子、椅子、地板等，
但是房子你是看不到全貌了。
你可以看到它的成员函数、成员变量，
但是实例本身呢？
this是一个指针，它时时刻刻指向你这个实例本身。
例如：
class A { int x; public: A():x(0) {} void add(int i) { x += i; } };
其中，非静态成员函数add在编译器看来应该是：
void add(int i, A* const this) { this->x += i; }
this在成员函数的开始前构造，在成员的结束后清除。当调用一个类的成员函数时，编译器将类的指针作为函数的this参数传递进去。如：
A a; a.add(5);
此处，编译器将会编译成：
a.add(5, &a);
下面，对代码进行反汇编分析下this指针。
a.add(5); 012613E6 push 5 //参数入栈 012613E8 lea ecx, [a] //对象a地址存储到ecx中 012613EB call A::add (1261113h) //调用函数 void add(int i) { … 012614BF pop ecx 012614C0 mov dword ptr [ebp-8], ecx //将对象地址从ecx中读出,写入到add的ebp-8处 x += i; 012614C3 mov eax, dword ptr [this] 012614C6 mov ecx, dword ptr [eax] 012614C8 add ecx, dword ptr [i] 012614CB mov edx, dword ptr [this] 012614CE mov dword ptr [edx], ecx }
反汇编的代码说明了编译器将对象本身的地址作为参数进行运算处理了。
再举个例子
class A { public: int x; A():x(0){} void add(A * p) { __asm { push eax mov eax,dword ptr[p] mov dword ptr[ebp-8], eax //this = p pop eax } x += 1; } }; int main(void) { A a1, a2; a1.add(&a2); cout<<"a1.x = "<<a1.x<<endl; cout<<"a2.x = "<<a2.x<<endl; return 0; }
程序执行结果为：
a1.x = 0
a2.x = 1
为什么程序运行结果是这样呢？
A的成员函数add对数据成员x进行加1操作，a1对象调用add后，本应使a1的x加1，可结果是对a2的x进行了加1。
函数add(A * p)中加了一段汇编代码：
mov eax,dword ptr[p] mov dword ptr[ebp-8], eax
这2行代码，将参数的值写入到ptr[ebp-8]中，即：this = p。在执行a1.add(&a2)时，this指针指向了a2，所以a1的x并没有变，而a2的x进行了加1。
this不是常规意义上的变量，它是一个系统变量，所以不能求其地址或对其赋值。this指针仅用于非静态函数中。
例如：
#include <iostream> using namespace std; class CNullPointCall { public: static void Test1( ); void Test2( ); void Test3(int iTest); void Test4( ); private: static int m_iStatic; int m_iTest; }; int CNullPointCall::m_iStatic = 0; void CNullPointCall::Test1( ) { cout << m_iStatic << endl; } void CNullPointCall::Test2( ) { cout << "Very Cool!" << endl; } void CNullPointCall::Test3(int iTest) { cout << iTest << endl; } void CNullPointCall::Test4( ) { cout << m_iTest << endl; } CNullPointCall *pNull = NULL; // 给指针赋值为空 void main( ) { pNull->Test1( ); // call 1，OK pNull->Test2( ); // call 2，OK pNull->Test3(13); // call 3，OK pNull->Test4( ); // call 4，error }
该程序能够成功编译，但在运行是会出错。
这是因为CNullPointCall的非静态成员函数Test4中隐含有this指针，但却没有CNullPointCall对象地址传递给this指针。
void CNullPointCall::Test4( CNullPointCall*const this ) { cout << this->m_iTest << endl; }
除了Test4之外，其余3个类成员函数的调用是成功的。
对于Test4来说，this的值也就是pNull的值，也就是说this的值为NULL，这就造成了程序的崩溃。Test1（）是静态函数，编译器不会给它传递this指针，所以能够正确调用，这里就相当于CNullPointCall::Test1( )。对于Test2（）和Test3（）两个成员函数，虽然编译器会给这两个函数传递this指针，但是它们并没有通过this指针来访问类的成员变量，因此Test2和Test3都可以正确调用。
在以下场景中，经常需要显式引用this指针：
（1）在类的非静态成员函数中返回类对象本身的时候，直接使用 return *this，例如：实现对象的链式引用。
（2）当参数与成员变量名相同时，如this->x = x，不能写成x = x。
（3）避免对同一对象进行赋值操作。
例1：实现对象的链式引用
#include <iostream> using namespace std; class Person { public: Person(string n, int a) { name = n; //这里的 name 等价于this->name age = a; //这里的 age 等价于this->age } int get_age(void) const { return age; } Person& add_age(int i) { age += i; return *this; // 返回本对象的引用 } private: string name; int age; }; int main(void) { Person Li("Li", 20); cout<<"Li age = "<< Li.get_age()<<endl; cout<<"Li add age = "<< Li.add_age(1).get_age()<<endl; //增加1岁的同时，可以对新的年龄直接输出; return 0; }
程序执行结果为：
Li age = 20
Li add age = 21
例2：参数与成员变量名相同的处理
#include <iostream> using namespace std; class Point { public: int x; Point ():x(0) {} Point (int a) { x=a; } void print() { cout<<"x = "<<x<<endl; } void set_x(int x) { x = x; } }; int main() { Point pt(5); pt.set_x(10); pt.print(); return 0; }
程序执行结果为：
x = 5
若将set_x函数改为：
void set_x(int x) { this->x = x; }
程序执行结果为：
x = 10
例3：避免对同一对象进行赋值操作
#include <iostream> using namespace std; class Location { int X,Y; //默认为私有的 public: void init(int x,int y) { X =x; Y =y; }; void assign(Location& pointer); int GetX() { return X; } int GetY() { return Y; } }; void Location::assign(Location& pointer) { if(&pointer!=this) //同一对象之间的赋值没有意义，所以要保证pointer不等于this { X=pointer.X; Y=pointer.Y; } } int main() { Location x; x.init(5,4);//初始化赋值 Location y; y.assign(x); cout<<"x.X = "<< x.GetX()<<" x.Y = "<<x.GetY(); cout<<"y.X = "<< y.GetX()<<" y.Y = "<<y.GetY(); return 0; }
问题：在一个类中，为什么静态成员函数（static member function）中不能使用this指针？
静态成员函数并不是针对某个类的实例对象，而是属于整个类的，为所有的对象实例所共有。他在作用域的范围内是全局的，独立于类的对象之外的。他只对类内部的静态成员变量做操作。当实例化一个类的对象时候，里面不存在静态成员的。this指针是相当于一个类的实例的指针，this是用来操作对象实例的内容的，既然静态成员函数和变量都是独立于类的实例对象之外的，他就不能用this指针。也不能操作非静态成员。