this指针

用类去定义对象时，系统会为每一个对象分配存储空间。如果一个类包括了数据和函数，要分别为数据和函数的代码分配存储空间。按理说，如果用同一个类定义了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指针。也不能操作非静态成员。