this指针的介绍和用法

大家好，又见面了，我是你们的朋友全栈君。

参考书籍，孙鑫视频教学，百度等。

—下文举的例子是错误的，楼主若有空会对此进行修改。记录时间：2019-3-4

this指针的介绍

this指针是面向对象程序设计的一项概念，在C++中，它表示当前运行的对象。在实现对象的方法时，this指针来获得该对象自身的引用。

正如class Family类，创建了Family类的两个对象，即Chen1和Chen2。

（1）假如Family类是”家庭“这个抽象。

（2）Chen1是你家，Chen2是邻居家。

（3）你的家庭成员中有个人名叫“陈皮”（”陈皮“是个 类里的成员，即可以假设是非静态成员函数、非静态成员变量、析构函数等，这里假设”陈皮“是个非静态成员变量，是个小孩），你隔壁家的家庭成员也有个人叫“陈皮”，也是个小孩。

（4）你是Chen1家的非静态成员函数void you()，是”陈皮“的家长。

（5）菜园是Chen1和Chen2这两个家庭共享的静态成员函数或者是静态成员变量。这里假设菜园是静态成员函数static void cai()，而菜是静态成员变量。即菜园和菜都是属于家庭类的，任何一个家庭都可以访问和改变它，但不能占为己有。

（6）this1假设是你家的家庭保姆，假设当前this1的联系里只有你家的地址，只服务于你这个家Chen1对象，原则上只能一对一服务你这个家庭,不能对其他家庭进行服务。

this用处比喻：

        如果你自己家的this1保姆今天过来工作于你的整个家庭，由于this1只能一对一服务，所以邻居家只好找到的是另外的this2作为他家的保姆。this2今天来不来都不关你家和你家的this1的事情。因此，你家的this1只能联系你家，而不能联系邻居家。相反，他家的this2的联系只有他家的地址，而没有你家的地址。

this1保姆找你家”陈皮“出去玩：

        如果this1想要找你家“陈皮”带出去玩，就必须来到你家里，进而通过你这个家长允许并获取”陈皮“喜欢玩什么等信息，并再与”陈皮“沟通交流，使”陈皮“心情大好并让他穿上衣服准备走人（改变情绪，改变装扮，即改变非静态成员变量的值，当然”陈皮“可以什么都不用改变）。由于this1不会联系有邻居家，跟this1无关，自然不会去访问邻居家。this1的沟通主要作用在家庭类的对象Chen1家庭中的你这个家长，即你这个非静态成员函数void you()。

this1保姆也可能对菜园感兴趣：

        如果this1对你家和邻居家共享的菜园感兴趣，就通过你的指引下，来参观你和邻居家共享的菜园，并获取菜园的信息。（this1在菜园中，既可以替你家来看看有什么好吃的菜，哪些菜长得如何，也可以替你家为菜园施肥料、除虫，但不会把这些行为或者菜园信息记录在this1的联系中），this1的联系始终只有你家的地址，不含其他家的地址，没有改变指向的说法。

this1保姆不认识邻居家：

       哪怕邻居家的this2今天不来，后天也不来，你家的this1因为不认识邻居家，也不会自作多情地对他家进行一番服务。只能通过你家的关系，把菜园里的菜都挖走了一大半，给你家做菜，也会导致邻居家天天因为吃饭时菜量不够而挨饿。邻居家只能喊他们的this2重新种菜，或者也全部挖走剩下的菜，来给他家做菜。即每个家庭都可以改变菜的份量。

 this1和this2都尽心服务于各自的家庭，但两者没有任何关系，从来都没有碰过面，也就没有过交际。

图解：

1.this指针是一个隐含的指针，它是指向对象本身，代表了对象的地址。

隐含的指针的说法，可以形象化成这样：
  当你进入一个房子后，你可以看见桌子、椅子、地板等，但是房子你是看不到全貌了。（即我们口头说的“房子”抽象概念是一个类，而我们亲眼看到的实际存在的”房子”类似一个对象。“桌子、椅子、地板等”类似成员函数、成员变量）

对于一个类的实例来说，你可以看到它的成员函数、成员变量，但是实例本身呢？ this是一个指针，它时时刻刻指向你这个实例本身。

2.一个类所有的对象调用的成员函数都是统一代码段。

那么成员函数又是怎么识别属于同一对象的数据成员呢？
原来，在对象调用pt.output(10,10)时，成员函数除了接受2个实参外，还接受到了一个对象pt的地址。这个地址被一个隐含的形参this指针所获取，它等同于执行this=&pt。所有对数据成员的访问都隐含地被加上前缀this->。
例如x是数据成员：
x=0;等价于this->x=0。

3.一个对象的this指针并不是对象本身的一部分，不会影响sizeof（对象）的结果。

this是一个指针，指向对象，保存的是对象的地址，所以在32位平台上，sizeof(this)始终是4个字节。sizeof(对象)或者sizeof(类名)是创建一个实例子后，包括了成员变量等占有内存的结果。

class A
{
public:
    int i;
    A(){ cout << endl; }
    void fun(){  cout << this << endl; }
    ~A(){};
};
int main()
{
    A a;
    a.fun();
    cout << &a << endl;
    return 0;
}

结果是：this指向对象a的地址与对象a的地址是一样的。

this作用域是在类内部，而且是在类的非静态成员函数中使用,实际引用并操作对象a的成员。

当在类的非静态成员函数中访问类的非静态成员的时候，编译器会自动将对象本身的地址作为一个隐含参数传递给函数。也就是说，即使你没有写上this指针，编译器在编译的时候也是加上this的，它作为非静态成员函数的隐含形参，对各成员的访问均通过this进行。

4.this到底是什么？（摘自c语言中文网）

1.this 实际上是成员函数的一个形参，在调用成员函数时将对象的地址作为实参传递给 this。不过 this 这个形参是隐式的，它并不出现在代码中，而是在编译阶段由编译器默默地将它添加到参数列表中。

2.在一个非静态的成员里面，this关键字就是一个指针，指向该函数的这次调用所针对的那个对象。在类a的非const成员函数里，this类型就是*a。但是this不是一个常规变量，所以不可以获取this的地址或者给它赋值。在类a的const成员函数里，this的类型是const a*，不可以对这个对象本身进行修改。

this的作用

1.使用this区分成员变量和局部变量。

当类中有两个同名变量，一个属于类（类的成员变量），而另一个属于某个特定的方法（方法中的局部变量）。

2.使用this简化构造函数的调用。

3.静态成员函数存在类中，只有一份拷贝。而非静态成员函数属于对象的，各自的对象都有各自的一份拷贝。

一个类所有的实例（对象）调用的非静态成员函数在内存中只有一份拷贝，尽管在内存中可能有多个对象，而非静态数据成员在类的每个对象所在内存中都存在着一份拷贝。this变量允许相同的实例方法为不同的对象工作。
每当调用一个实例的非静态成员函数时，this变量将被设置成引用该实例函数的特定的类对象。方法的代码接着会与this所代表的对象的特定数据建立关联。

4.为了分清同变量名，引用指针。

假设：void output（int x，int y）函数里面的两个形参和类的公有的两个变量名一致时，分析如下实例：

class Point
{public:
int x;
int y;
Point(int a,int b){x=a;y=b;}
void output()//output函数{cout<<x<<endl<<y<<endl;}
void output(int x,int y)//output函数重载{x=x;y=y;}
};
void main()
{
Point pt(3,3);
pt.output(5,5);
}

输出结果为：
3
3
原因：在output(int x,int y)中，x，y都属于output重载函数里面的形参，并没有调用类里面的x,y;

把output(int x,int y)函数改成：

void output(int x,int y)//output函数重载
{
this->x=x;
this->y=y;
}

输出结果：
5
5

this指针程序示例

  this指针存在于类的成员函数中,指向被调用函数所在的类实例的地址。
  根据以下程序来说明this指针

   #include<iostream.h>
   class Point
   {
   int x, y;
   public:
   Point(int a, int b) {x=a; y=b;}
   void MovePoint( int a, int b){ x+=a; y+=b;}
   void print(){ cout<<"x="<<x<<"y="<<y<<endl;}
   };
   void main( )
   {
   Point point1( 10,10);
   point1.MovePoint(2,2);
   point1.print( );
   }

当对象point1调用MovePoint(2,2)函数时，即将point1对象的地址传递给了this指针。
   MovePoint函数的原型应该是 void MovePoint( Point *this, int a, int b);第一个参数是指向该类对象的一个指针，我们在定义成员函数时没看见是因为这个参数在类中是隐含的。这样point1的地址传递给了this，所以在MovePoint函数中便显式的写成：
   void MovePoint(int a, int b) { this->x +=a; this-> y+= b;}
   即可以知道，point1调用该函数后，也就是point1的数据成员被调用并更新了值。
   即该函数过程可写成 point1.x+= a; point1. y + = b;

摘自百度百科：

详细解析编辑
        在前面曾经提到过： 每个对象中的数据成员都分别占有存储空间，如果对同一个类定义了n个对象，则有n组同样大小的空间以存放n个对象中的数据成员。但是，不同对象都调用同一个函数代码段。
        那么，当不同对象的成员函数引用数据成员时，怎么能保证引用的是所指定的对象的数据成员呢？假如，对于例程序中定义的Box类，定义了3个同类对象a,b,c。
            1.如果有a.volume( ) ，应该是引用对象a中的height，width和length，计算出长方体a的体积。
            2.如果有b.volume( ) ，应该是引用对象b中的height，width和length，计算出长方体b的体积。
        而现今都用同一个函数段（volume()），系统怎样使它分别引用a或b中的数据成员呢？在每一个成员函数中都包含一个特殊的指针，这个指针的名字是固定的，称为this指针。它是指向本类对象的指针，它的值是当前被调用的成员函数所在的对象的起始地址。
         例如，当调用成员函数a.volume时，编译系统就把对象a的起始地址赋给this指针，于是在成员函数引用数据成员时，就按照this的指向找到对象a的数据成员。例如volume函数要计算height*width*length的值，实际上是执行：
(this->height)*(this->width)*(this->length)
由于当前this指向a，因此相当于执行：
(a.height)*(a.width)*( a.length)
这就计算出长方体a的体积。
          同样如果有b.volume( ) ，编译系统就把对象b的起始地址赋给成员函数volume的this指针，显然计算出来的是长方体b的体积。this指针是隐式使用的，它是作为参数被传递给成员函数的。
本来，成员函数volume的定义如下：
int Box::volume( )
{

return (height*width*length);
}
C++把它处理为
int Box::volume(Box *this)
{

return (this->height * this->width * this->length);
}
即在成员函数的形参表列中增加一个this指针。
在调用该成员函数时，实际上是用以下方式调用的：
a.volume(&a);
将对象a的地址传给形参this指针。然后按this的指向去引用其他成员。
需要说明： 这些都是编译系统自动实现的，编程序者不必人为地在形参中增加this指针，也不必将对象a的地址传给this指针。在需要时也可以显式地使用this指针。

例如在Box类的volume函数中，下面两种表示方法都是合法的、相互等价的。
return (height * width * length); //隐含使用this指针
return (this->height * this->width * this->length); //显式使用this指针
可以用*this表示被调用的成员函数所在的对象，*this就是this所指向的对象，即当前的对象。

例如在成员函数a.volume( )的函数体中，如果出现*this，它就是本对象a。上面的return语句也可写成
return((*this).height * (*this).width * (*this).length);
注意*this两侧的括号不能省略，不能写成*this.height。
所谓“调用对象a的成员函数f”，实际上是在调用成员函数f时使this指针指向对象a，从而访问对象a的成员。在使用“调用对象a的成员函数f”时，应当对它的含义有正确的理解。

应用参考编辑

this指针只能在一个类的成员函数中调用，它表示当前对象的地址。下面是一个例子(选自《C/C++程序员宝典》面试题91)：

voidDate::setMonth(intmn)
{
  month=mn;
  this->month=mn;
  (*this).month=mn;
  //这三句是等价的
}

1.this只能在成员函数中使用。

全局函数，静态函数都不能使用this。
实际上，成员函数默认第一个参数为T*const register this。
如：
class A{public: int func( int p){}};
其中，func的原型在编译器看来应该是： int func(A*const register this, int p);

2. 由此可见，this在成员函数的开始前构造的，在成员的结束后清除。

这个生命周期同任一个函数的参数是一样的，没有任何区别。
当调用一个类的成员函数时，编译器将类的指针作为函数的this参数传递进去。如：
A a;
a.func(10);
此处，编译器将会编译成： A::func(&a, 10);
嗯，看起来和静态函数没差别，对吗？不过，区别还是有的。编译器通常会对this指针做一些优化的，因此，this指针的传递效率比较高－－如vc通常是通过ecx寄存器来传递this参数。

3. 回答

#1:this指针是什么时候创建的?
this在非静态成员中有意义，作为右值可以直接在编译时确定其存在，运行时无所谓创建。

#2:this指针存放在何处？

堆，栈，全局变量，还是其他？

由上一问可知，this指针无需显式储存内存中。只要存储对象的内存位置确定，对应的this指针就被确定了。

#3:this指针如何传递给类中函数的?绑定?还是在函数参数的首参数就是this指针.那么this指针又是如何找到类实例后函数的?
this是通过函数参数的首参数来传递的。this指针是在调用之前生成的。类实例后的函数，没有这个说法。类在实例化时，只分配类中的变量空间，并没有为函数分配空间。自从类的函数定义完成后，它就在那儿，不会跑的。
#4:this指针如何访问类中变量的？
如果不是类，而是结构的话，那么，如何通过结构指针来访问结构中的变量呢？如果你明白这一点的话，那就很好理解这个问题了。
在C++中，struct是一种类类型，struct和class只有一个区别的：class的成员和继承默认的访问控制权限是private，而struct是public。
this是class或public的对象的指针。
#5:我们只有获得一个对象后，才能通过对象使用this指针,如果我们知道一个对象this指针的位置可以直接使用吗?
this指针只有在非静态成员中才有意义。获得一个对象后，不需要在类外部使用this对其操作。应当注意this是一个右值（方法的一个隐式参数） ，不存在所谓的this的“位置”，只是this表示了对象的存储位置而已。&this违反语义规则，是错误的用法，不会编译通过。
#6:每个类编译后,是否创建一个类中函数表保存函数指针,以便用来调用函数?
一般来说，对于类成员函数（不论是静态还是非静态的成员函数）都不需要创建一个在运行时的函数表来保存。只有虚函数才会被放到函数表中。
但是，即使是虚函数，如果编译器能明确知道调用的是哪个函数，编译器就不会通过函数表中的指针来间接调用，而是可以直接调用该函数。

本文小结

1.this是一个指针，指向对象的地址，不是对象本身。

class A
{
private:
    int i;
public:
    void fun()
{
      this->i;
};
    A();
   ~A();
}
int main()
{
    A a1,a2;
    a1.fun();//一个this指向a1的地址，作用a1的fun
    a2.fun();//另一个this指向a2的地址，作用a2的fun
}

2.this只能作用于在类内的非静成员函数里，并不在静态成员函数起作用。

class A
{
private:
    int i;
    static int j;
public:
    void fun();
    static void s_fun()
{
//由于静态成员函数属于类的，是每个对象共享的，所以this不能在这里起作用。
     this->i;//错误，this引用任何成员都是错误。
};
    A();
   ~A();
}

3.通过this引用出来的是对象的成员函数（包括静态成员函数）和成员变量（包括静态成员变量），析构函数等。但不能是构造函数。

class A
{
private:
   int i;
   static int j;
public:
    void fun()
{
     this->i;//正确
     this->j;//正确
     this->s_fun();//正确
     this->fun();//正确
     this->A();//错误
     this->~A();//正确
};
    static void s_fun();
    A();
   ~A();
}

this面试题

（1）选自《C/C++程序员宝典》面试题91。

#include<iostream>
using namespace std;
class A
{
public:
    A()
    {
        a = b = 0;
    }
    A(int a, int b)
    {
        this->a = a;
        this->b = b;
    }
    void copy(A &aa);//对象引用作函数参数
    void print()
    {
        cout << a << "," <<b<< endl;
    }
private:
    int a, b;
};
void A::copy(A &aa)
{
    if (this == &aa)
        return;//这个this是操作对象a1的地址
    *this = aa;//*this操作该成员函数的对象，在这里是对象a1
    //对象aa赋给a1，aa具有的数据成员的值赋给a1的数据成员
}

int main()
{
    A a1, a2(3, 4);
    a1.copy(a2);
    a1.print();
    return 0;
}

当对一个对象调用成员函数时，编译程序先将对象的地址赋值给this指针，然后调用成员函数，每次成员函数存取数据成员时，由隐含作用this指针。而通常不去显式地使用this指针来引用数据成员。同样也可以使用*this 来标识调用该成员函数的对象。