this指针的介绍和用法

ゞ浴缸里的玫瑰 2022-07-11 08:05 378阅读 0赞

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

**---下文举的例子是错误的，楼主若有空会对此进行修改。记录时间：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**因为不认识邻居家，也不会自作多情地对他家进行一番服务。只能通过你家的关系，把菜园里的菜都挖走了一大半，给你家做菜，也会导致邻居家天天因为吃饭时菜量不够而挨饿。邻居家只能喊他们的**t****his2**重新种菜，或者也全部挖走剩下的菜，来给他家做菜。即**每个家庭都可以改变菜的份量。**

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

**图解：**

![20181220201506491][]

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(类名)是创建一个实例子后，包括了成员变量等占有内存的结果。**

![复制代码][20181220201506509]

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;
    }

![复制代码][20181220201506509]

结果是：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）函数里面的两个形参和类的公有的两个变量名一致时，分析如下实例：

![复制代码][20181220201506509]

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);
    }

![复制代码][20181220201506509]

输出结果为：  
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指针

![复制代码][20181220201506509]

#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( );
       }

![复制代码][20181220201506509]

当对象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)：

![复制代码][20181220201506509]

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

![复制代码][20181220201506509]

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是一个指针，指向对象的地址，不是对象本身。

![复制代码][20181220201506509]

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
    }

![复制代码][20181220201506509]

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

![复制代码][20181220201506509]

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

![复制代码][20181220201506509]

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

![复制代码][20181220201506509]

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();
    }

![复制代码][20181220201506509]

## this面试题 ##

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

![复制代码][20181220201506509]

#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;
    }

![复制代码][20181220201506509]

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

[20181220201506491]: /images/20220711/63af46a74448433fbe75af4f1105b224.png
[20181220201506509]: /images/20220711/eb2e5684e93e4e7fb175f7dadd6b02a4.png