Question

this关键字的目的是什么？类中的方法是否可以访问同一个类中的其他对等成员？有什么需要调用this来调用类中的对等方法？

Answer 1

两个主要用途：

将*this或this作为参数传递给其他非类方法。

void do_something_to_a_foo(Foo *foo_instance);

void Foo::DoSomething()
{
    do_something_to_a_foo(this);
}

允许您删除成员变量和函数参数之间的歧义。这在构造函数中很常见。
```
MessageBox::MessageBox(const string& message)
{
  this->message = message;
}
```
（虽然在这个特定的例子中，initialization list通常比分配更适合。）

Answer 2

帮助消除歧义。
将自己作为参数传递或自行返回

示例：

struct A
{
    void test(int x)
    {
        this->x = x;                 // Disambiguate. Show shadowed variable.
    }
    A& operator=(A const& copy)
    {
        x = copy.x;
        return *this;                // return a reference to self
    }

    bool operator==(A const& rhs) const
    {
         return isEqual(*this, rhs); // Pass yourself as parameter.
                                     // Bad example but you can see what I mean.
    }

    private:
        int x;
};

Answer 3

考虑参数与类成员同名的情况：

void setData(int data){
  this->data = data;
}

Answer 4

表达式*this通常用于从成员函数返回当前对象：

return *this;

this指针也用于防止自我引用：

if (&Object != this) {
// do not execute in cases of self-reference

Answer 5

解决成员变量/函数与其他范围定义的变量之间的模糊性
向读者明确说明正在调用成员函数或正在引用成员变量的代码。
在IDE中触发IntelliSense（虽然可能只是我）。

Answer 6

它允许您将当前对象传递给另一个函数：

class Foo;

void FooHandler(Foo *foo);

class Foo
{
    HandleThis()
    {
       FooHandler(this);
    }  
};

Answer 7

要记住一些要点

该指针存储地址类实例，启用指针成员访问该成员班级的功能。
不计算此指针计算物体的大小。
无法访问此指针静态成员函数。
此指针不可修改

请查看以下示例以了解如何使用本C ++教程中介绍的'this'指针。

class this_pointer_example // class for explaining C++ tutorial 
{
    int data1;
 public:
    //Function using this pointer for C++ Tutorial
    int getdata()
    { 
        return this->data1;
    } 
  //Function without using this pointer 
  void setdata(int newval)
  {
       data1 = newval;
  }
};

因此，成员函数可以通过使用此指针获得数据成员的访问权限。另请阅读this以了解有关此指针的其他基本知识

Answer 8

它允许你绕过被方法参数或局部变量遮蔽的成员。

Answer 9

类中的this指针是对自身的引用。例如，在这种情况下需要它：

class YourClass
{
   private:
      int number;

   public:
      YourClass(int number)
      {
         this->number = number;
      }
}

（虽然使用初始化列表可以做得更好，这可以用于演示）

在这种情况下，您有2个同名的变量

班级私人“号码”
构造函数参数“number”

使用this->number，让编译器知道您正在分配类私有变量。

Answer 10

例如，如果你写一个operator=()，你必须检查自我分配。

class C {
public:
    const C& operator=(const C& rhs)
    {
        if(this==&rhs) // <-- check for self assignment before anything
            return *this;
        // algorithm of assignment here
        return *this; // <- return a reference to yourself
    }
};

Answer 11

this指针是一种访问特定对象的当前实例的方法。它可以用于多种目的：

作为实例标识表示（例如与其他实例比较）
用于数据成员与局部变量消歧
将当前实例传递给外部对象
将当前实例强制转换为其他类型

Answer 12

另一个目的是链接对象：考虑以下课程：

class Calc{
private:
    int m_value;

public:
    Calc() { m_value = 0; }

    void add(int value) { m_value += value; }
    void sub(int value) { m_value -= value; }
    void mult(int value) { m_value *= value; }

    int getValue() { return m_value; }
};

如果你想添加5，减去3，然后乘以4，你必须这样做：＃包括 int main（） { Calc calc; calc.add（5）; //返回void calc.sub（3）; //返回void calc.mult（4）; //返回void

    std::cout << calc.getValue() << '\n';
    return 0;
}

但是，如果我们让每个函数返回* this，我们可以将调用链接在一起。这是具有“可链接”功能的Calc的新版本：

class Calc
{
private:
    int m_value;

public:
    Calc() { m_value = 0; }

    Calc& add(int value) { m_value += value; return *this; }
    Calc& sub(int value) { m_value -= value; return *this; }
    Calc& mult(int value) { m_value *= value; return *this; }

    int getValue() { return m_value; }
};

请注意，add（），sub（）和mult（）现在返回* this。因此，这允许我们执行以下操作：

#include <iostream>
int main()
{
    Calc calc;
    calc.add(5).sub(3).mult(4);

    std::cout << calc.getValue() << '\n';
    return 0;
}

我们有效地将三行压缩成一个表达式。

复制自：http://www.learncpp.com/cpp-tutorial/8-8-the-hidden-this-pointer/

Answer 13

c ++中的双冒号在技术上称为＆＃34;一元范围分辨率运算符＆＃34;。基本上它是在我们重复使用相同的变量时使用的，例如在我们的＆＃34; main＆＃34; function（我们的变量将被称为局部变量）和main（变量称为全局变量）。 C ++将总是执行内部变量（即本地变量）。所以想象一下你想要使用全局变量＆＃34; Conundrum＆＃34;而不是本地的，因为全局的表示为浮点而不是整数：

#include <iostream>
using namespace std;

float Conundrum=.75;

int main()
{
  int Conundrum =75;
  cout<<::Conundrum;

}

所以在这种情况下，程序将使用我们的浮动难题而不是int难题。

Answer 14

它还允许对象自行删除。这用于智能指针实现，COM编程和（我认为）XPCOM。

代码看起来像这样（摘自一些较大的代码）：

class counted_ptr
{
private:
    counted_ptr(const counted_ptr&);
    void operator =(const counted_ptr&);

    raw_ptr_type            _ptr;
    volatile unsigned int   _refcount;
    delete_function         _deleter;
public:

    counted_ptr(raw_ptr_type const ptr, delete_function deleter)
        : _ptr(ptr), _refcount(1), _deleter(deleter) {}
    ~counted_ptr() { (*_deleter)(_ptr); }
    unsigned int addref() { return ++_refcount; }
    unsigned int release()
    {
        unsigned int retval = --_refcount;
        if(0 == retval)
>>>>>>>>        delete this;
        return retval;
    }
    raw_ptr_type get() { return _ptr; }
};

Answer 15

它还允许您在赋值运算符重载中测试自赋值：

Object & operator=(const Object & rhs) {
  if (&rhs != this) {
    // do assignment
  }
  return *this;
}

Answer 16

为清楚起见，或当局部变量或参数与成员变量同名时解决歧义。

Answer 17

有时您希望直接引用当前对象，以便将其传递给其他方法或存储以供以后使用。

此外，方法调用始终针对对象进行。当你在当前对象中的另一个方法中调用方法时，相当于写这个 - ＆gt; methodName（）

您也可以使用它来访问成员而不是“隐藏”它的变量或参数名称，但隐藏名称是（恕我直言）不良做法。例如：

void C :: setX（int x） { this-＆gt; x = x; }

C ++中“this”指针的目的是什么？

17 个答案: