'this' pointer in C++-优快云博客

本文详细介绍了C++中this指针的用途，包括用于访问当前对象成员、返回引用以简化对象操作、解决局部变量与成员变量重名冲突等问题，并通过示例代码展示了其在构造函数、成员函数中的应用。同时，文中还分析了常见错误及解决方案，如参数名称与成员名称冲突、静态成员函数中的this指针不可用、不返回对象导致临时对象创建等。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

　　The ‘this’ pointer is passed as a hidden argument to all nonstatic member function calls and is available as a local variable within the body of all nonstatic functions. 'this' pointer is a constant pointer that holds the memory address of the current object. ‘this’ pointer is not available in static member functions as static member functions can be called without any object (with class name).
　　For a class X, the type of this pointer is ‘X* const’. Also, if a member function of X is declared as const, then the type of this pointer is ‘const X *const’.

　　Following are the situations where ‘this’ pointer is used:

　　（1）When local variable’s name is same as member’s name

 1 #include<iostream>
 2 using namespace std;
 3  
 4 /* local variable is same as a member's name */
 5 class Test
 6 {
 7 private:
 8    int x;
 9 public:
10    void setX (int x)
11    {
12        // The 'this' pointer is used to retrieve the object's x
13        // hidden by the local variable 'x'
14        this->x = x;
15    }
16    void print() 
17   { 
18        cout << "x = " << x << endl; 
19    }
20 };
21  
22 int main()
23 {
24    Test obj;
25    int x = 20;
26    obj.setX(x);
27    obj.print();
28    return 0;
29 }

　　Output:

　　x = 20
　　

　　For constructors, initializer list can also be used when parameter name is same as member’s name.

　　（2）To return reference to the calling object

1 /* Reference to the calling object can be returned */
2 Test& Test::func ()
3 {
4    // Some processing
5    return *this;
6 }

　　When a reference to a local object is returned, the returned reference can be used to chain function calls on a single object.

 1 #include<iostream>
 2 using namespace std;
 3  
 4 class Test
 5 {
 6 private:
 7   int x;
 8   int y;
 9 public:
10   Test(int x = 0, int y = 0) 
11   { 
12         this->x = x; 
13         this->y = y; 
14   }
15   Test &setX(int a) 
16   { 
17         x = a; 
18         return *this; 
19   }
20   Test &setY(int b) 
21   { 
22          y = b; 
23          return *this; 
24    }
25   void print() 
26   { 
27          cout << "x = " << x << " y = " << y << endl; 
28    }
29 };
30  
31 int main()
32 {
33   Test obj1(5, 5);
34  
35   // Chained function calls.  All calls modify the same object
36   // as the same object is returned by reference
37   obj1.setX(10).setY(20);
38  
39   obj1.print();
40   return 0;
41 }

　　Output:

　　x = 10 y = 20

　　Exercise:
　　Predict the output of following programs. If there are compilation errors, then fix them.

　　Question 1

 1 #include<iostream>
 2 using namespace std;
 3  
 4 class Test
 5 {
 6 private:
 7   int x;
 8 public:
 9   Test(int x = 0) 
10   { 
11       this->x = x; 
12   }
13   void change(Test *t) 
14   { 
15       this = t; 
16   }
17   void print() 
18   { 
19       cout << "x = " << x << endl; 
20   }
21 };
22  
23 int main()
24 {
25   Test obj(5);
26   Test *ptr = new Test (10);
27   obj.change(ptr);
28   obj.print();
29   return 0;
30 }

　　类Test的成员函数change有问题，现修改为：

1 void change(Test *t) 
2 { 
3       *this = *t; 
4 }

　　因为this指针为const指针，其本身无法进行修改。修改后的输出内容为：　　10

　　Question 2

 1 #include<iostream>
 2 using namespace std;
 3  
 4 class Test
 5 {
 6 private:
 7   int x;
 8   int y;
 9 public:
10   Test(int x = 0, int y = 0) 
11   { 
12       this->x = x; 
13       this->y = y; 
14   }
15   static void fun1() 
16   { 
17       cout << "Inside fun1()"; 
18   }
19   static void fun2() 
20   { 
21       cout << "Inside fun2()"; 
22       this->fun1(); 
23   }
24 };
25  
26 int main()
27 {
28   Test obj;
29   obj.fun2();
30   return 0;
31 }

　　编译错误："'fun2' : static member functions do not have 'this' pointers"

　　Question 3

 1 #include<iostream>
 2 using namespace std;
 3  
 4 class Test
 5 {
 6 private:
 7   int x;
 8   int y;
 9 public:
10   Test (int x = 0, int y = 0) 
11   { 
12       this->x = x; 
13       this->y = y; 
14   }
15   Test setX(int a) 
16   { 
17       x = a; 
18       return *this; 
19   }
20   Test setY(int b) 
21   { 
22       y = b; 
23       return *this; 
24   }
25   void print() 
26   { 
27       cout << "x = " << x << " y = " << y << endl; 
28   }
29 };
30  
31 int main()
32 {
33   Test obj1;
34   obj1.setX(10).setY(20);
35   obj1.print();
36   return 0;
37 }

　　Output：　　x = 10 　y = 0

　　When we do not return an object by reference, a temporary object is created (which contains copy of the original object)and returned. In question 3, setX() modifies obj1, but returns a different object because return by value is used. So setY() modifies the temporary object.

　　Question 4

 1 #include<iostream>
 2 using namespace std;
 3  
 4 class Test
 5 {
 6 private:
 7   int x;
 8   int y;
 9 public:
10   Test(int x = 0, int y = 0) 
11   { 
12       this->x = x; 
13       this->y = y; 
14   }
15   void setX(int a) 
16   { 
17       x = a; 
18   }
19   void setY(int b) 
20   { 
21       y = b; 
22   }
23   void destroy()  
24   { 
25       delete this; 
26   }
27   void print() 
28   { 
29       cout << "x = " << x << " y = " << y << endl; 
30   }
31 };
32  
33 int main()
34 {
35   Test obj;
36   obj.destroy();
37   obj.print();
38   return 0;
39 }