用类去定义对象时，系统会为每一个对象分配存储空间。如果一个类包括了数据和函数，要分别为数据和函数的代码分配存储空间。按理说，如果用同一个类定义了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是一个指针，它时时刻刻指向你这个实例本身。
转自：http://blog.csdn.net/chenyt01/article/details/51316022
例如：
按 Ctrl+C 复制代码
按 Ctrl+C 复制代码
其中，非静态成员函数add在编译器看来应该是：
void add(int i, A* const this)
{
this->x += i;
}
this在成员函数的开始前构造，在成员的结束后清除。当调用一个类的成员函数时，编译器将类的指针作为函数的this参数传递进去。如：
A a; a.add(5);
此处，编译器将会编译成：
a.add(5, &a);
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指针。也不能操作非静态成员。