blocks|key|1530500|text|如果在与现有成员同名的方法中声明局部变量，则必须使用this->var来访问类成员，而不是局部变量。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1530501|#include+<iostream>
using+namespace+std;
class+A
{
++++public:
++++++++int+a;

++++++++void+f()+{
++++++++++++a+=+4;
++++++++++++int+a+=+5;
++++++++++++cout+<<+a+<<+endl;
++++++++++++cout+<<+this->a+<<+endl;
++++++++}
};

int+main()
{
++++A+a;
++++a.f();
}|code-block|syntax|javascript|1530502|打印：|1530503|5|1530504|4.|1530505|entityMap^0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|O|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|Q|8|@]|9|@]|A|$]]|$1|I|3|J|5|6|7|R|8|@]|9|@]|A|$]]|$1|K|3|L|5|6|7|S|8|@]|9|@]|A|$]]|$1|M|3|-4|5|6|7|T|8|@]|9|@]|A|$]]]|N|$]]

If you declare a local variable in a method with the same name as an existing member, you will have to use this->var to access the class member instead of the local variable.

<pre><code>#include &lt;iostream&gt;
using namespace std;
class A
{
 public:
 int a;

 void f() {
 a = 4;
 int a = 5;
 cout &lt;&lt; a &lt;&lt; endl;
 cout &lt;&lt; this-&gt;a &lt;&lt; endl;
 }
};

int main()
{
 A a;
 a.f();
}
</code></pre>

prints:

5 
4

blocks|key|1530564|text|您需要使用this来消除参数/局部变量和成员变量之间的歧义。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1530565|class+Foo
{
protected:
++int+myX;

public:
++Foo(int+myX)
++{
++++this->myX+=+myX;+
++}
};|code-block|syntax|javascript|1530566|entityMap^0|5|4|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@$9|N|A|O|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|P|8|@]|D|@]|E|$I|J]]|$1|K|3|-4|5|6|7|Q|8|@]|D|@]|E|$]]]|L|$]]

You need to use <code>this</code> to disambiguate between a parameters/local variables and member variables.

<pre><code>class Foo
{
protected:
 int myX;

public:
 Foo(int myX)
 {
 this-&gt;myX = myX; 
 }
};
</code></pre>

blocks|key|1530609|text|只有在两个可能的名称空间中有一个同名的符号时，才需要使用this->。举个例子：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1530610|class+A+{
public:
+++void+setMyVar(int);
+++void+doStuff();

private:
+++int+myVar;
}

void+A::setMyVar(int+myVar)
{
++this->myVar+=+myVar;++//+<-+Interesting+point+in+the+code
}

void+A::doStuff()
{
++int+myVar+=+::calculateSomething();
++this->myVar+=+myVar;+//+<-+Interesting+point+in+the+code
}|code-block|syntax|javascript|1530611|在代码中有趣的地方，引用myVar将引用本地(参数或变量)+myVar。为了访问也称为myVar的类成员，您需要显式地使用"this->“。|1530612|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|L|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|M|8|@]|9|@]|A|$]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

You only have to use this-> if you have a symbol with the same name in two potential namespaces. Take for example:

<pre><code>class A {
public:
 void setMyVar(int);
 void doStuff();

private:
 int myVar;
}

void A::setMyVar(int myVar)
{
 this-&gt;myVar = myVar; // &lt;- Interesting point in the code
}

void A::doStuff()
{
 int myVar = ::calculateSomething();
 this-&gt;myVar = myVar; // &lt;- Interesting point in the code
}
</code></pre>

At the interesting points in the code, referring to myVar will refer to the local (parameter or variable) myVar. In order to access the class member also called myVar, you need to explicitly use "this->".

blocks|key|1315526|text|通常情况下，您不必这样做，this->是隐含的。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1315527|有时，存在名称歧义，可用于消除类成员和局部变量的歧义。但是，这里是一个完全不同的情况，其中显式需要this->。|1315528|考虑以下代码：|1315529|template<class+T>
struct+A+{
+++int+i;
};

template<class+T>
struct+B+:+A<T>+{

++++int+foo()+{
++++++++return+this->i;
++++}

};

int+main()+{
++++B<int>+b;
++++b.foo();
}|code-block|syntax|javascript|1315530|如果省略this->，编译器就不知道如何处理i，因为它可能存在于A的所有实例化中，也可能不存在。为了告诉它i确实是A<T>的成员，对于任何T，this->前缀都是必需的。|1315531|注意:仍然可以使用以下命令省略this->前缀：|1315532|template<class+T>
struct+B+:+A<T>+{

++++using+A<T>::i;+//+explicitly+refer+to+a+variable+in+the+base+class

++++int+foo()+{
++++++++return+i;+//+i+is+now+known+to+exist
++++}

};|1315533|entityMap^0|D|6|0|1D|6|0|0|0|4|6|M|1|W|1|1H|1|1L|4|1X|1|1Z|6|0|F|6|0|0^^$0|@$1|2|3|4|5|6|7|W|8|@$9|X|A|Y|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|Z|8|@$9|10|A|11|B|C]]|D|@]|E|$]]|$1|H|3|I|5|6|7|12|8|@]|D|@]|E|$]]|$1|J|3|K|5|L|7|13|8|@]|D|@]|E|$M|N]]|$1|O|3|P|5|6|7|14|8|@$9|15|A|16|B|C]|$9|17|A|18|B|C]|$9|19|A|1A|B|C]|$9|1B|A|1C|B|C]|$9|1D|A|1E|B|C]|$9|1F|A|1G|B|C]|$9|1H|A|1I|B|C]]|D|@]|E|$]]|$1|Q|3|R|5|6|7|1J|8|@$9|1K|A|1L|B|C]]|D|@]|E|$]]|$1|S|3|T|5|L|7|1M|8|@]|D|@]|E|$M|N]]|$1|U|3|-4|5|6|7|1N|8|@]|D|@]|E|$]]]|V|$]]

Usually, you do not have to, <code>this-&gt;</code> is implied. 

Sometimes, there is a name ambiguity, where it can be used to disambiguate class members and local variables. However, here is a completely different case where <code>this-&gt;</code> is explicitly required.

Consider the following code:

<pre><code>template&lt;class T&gt;
struct A {
 int i;
};

template&lt;class T&gt;
struct B : A&lt;T&gt; {

 int foo() {
 return this-&gt;i;
 }

};

int main() {
 B&lt;int&gt; b;
 b.foo();
}
</code></pre>

If you omit <code>this-&gt;</code>, the compiler does not know how to treat <code>i</code>, since it may or may not exist in all instantiations of <code>A</code>. In order to tell it that <code>i</code> is indeed a member of <code>A&lt;T&gt;</code>, for any <code>T</code>, the <code>this-&gt;</code> prefix is required.

Note: it is possible to still omit <code>this-&gt;</code> prefix by using:

<pre><code>template&lt;class T&gt;
struct B : A&lt;T&gt; {

 using A&lt;T&gt;::i; // explicitly refer to a variable in the base class

 int foo() {
 return i; // i is now known to exist
 }

};
</code></pre>

blocks|key|1315598|text|其他的用法(当我读到总结和一半的问题时，我想....)，如果你想转换当前对象，将其绑定在函数对象中，或者将其与指向成员的指针一起使用，则会忽略其他答案中的命名消歧。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1315599|投射|1315600|void+Foo::bar()+{
++++misc_nonconst_stuff();
++++const+Foo*+const_this+=+this;
++++const_this->bar();+//+calls+const+version

++++dynamic_cast<Bar*>(this)->bar();+//+calls+specific+virtual+function+in+case+of+multi-inheritance
}+

void+Foo::bar()+const+{}|code-block|syntax|javascript|1315601|绑定|1315602|void+Foo::baz()+{
+++++for_each(m_stuff.begin(),+m_stuff.end(),++bind(&Foo:framboozle,+this,+_1));++++++++
+++++for_each(m_stuff.begin(),+m_stuff.end(),+[this](StuffUnit&+s)+{+framboozle(s);+});+++++++++
}+

void+Foo::framboozle(StuffUnit&+su)+{}

std::vector<StuffUnit>+m_stuff;|1315603|ptr到成员|1315604|void+Foo::boz()+{
++++bez(&Foo::bar);
++++bez(&Foo::baz);
}+

void+Foo::bez(void+(Foo::*func_ptr)())+{
++++for+(int+i=0;+i<3;+%2B%2Bi)+{
++++++++(this->*func_ptr)();
++++}
}|1315605|希望它能帮助我们展示这个->成员之外的其他用途。|1315606|entityMap^0|0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|U|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|V|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|W|8|@]|9|@]|A|$G|H]]|$1|I|3|J|5|6|7|X|8|@]|9|@]|A|$]]|$1|K|3|L|5|F|7|Y|8|@]|9|@]|A|$G|H]]|$1|M|3|N|5|6|7|Z|8|@]|9|@]|A|$]]|$1|O|3|P|5|F|7|10|8|@]|9|@]|A|$G|H]]|$1|Q|3|R|5|6|7|11|8|@]|9|@]|A|$]]|$1|S|3|-4|5|6|7|12|8|@]|9|@]|A|$]]]|T|$]]

The other uses for this (as I thought when I read the summary and half the question... .), disregarding (bad) naming disambiguation in other answers, are if you want to cast the current object, bind it in a function object or use it with a pointer-to-member.

<h2>Casts</h2>

<pre><code>void Foo::bar() {
 misc_nonconst_stuff();
 const Foo* const_this = this;
 const_this-&gt;bar(); // calls const version

 dynamic_cast&lt;Bar*&gt;(this)-&gt;bar(); // calls specific virtual function in case of multi-inheritance
} 

void Foo::bar() const {}
</code></pre>

<h2>Binding</h2>

<pre><code>void Foo::baz() {
 for_each(m_stuff.begin(), m_stuff.end(), bind(&amp;Foo:framboozle, this, _1)); 
 for_each(m_stuff.begin(), m_stuff.end(), [this](StuffUnit&amp; s) { framboozle(s); }); 
} 

void Foo::framboozle(StuffUnit&amp; su) {}

std::vector&lt;StuffUnit&gt; m_stuff;
</code></pre>

<h2>ptr-to-member</h2>

<pre><code>void Foo::boz() {
 bez(&amp;Foo::bar);
 bez(&amp;Foo::baz);
} 

void Foo::bez(void (Foo::*func_ptr)()) {
 for (int i=0; i&lt;3; ++i) {
 (this-&gt;*func_ptr)();
 }
}
</code></pre>

Hope it helps to show other uses of this than just this->member.

blocks|key|1315673|text|另一种情况是调用运算符。例如，代替|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1315674|bool+Type::operator!=(const+Type&+rhs)
{
++++return+!operator==(rhs);
}|code-block|syntax|javascript|1315675|你可以说|1315676|bool+Type::operator!=(const+Type&+rhs)
{
++++return+!(*this+==+rhs);
}|1315677|哪个可能更易读。另一个例子是复制和交换：|1315678|Type&+Type::operator=(const+Type&+rhs)
{
++++Type+temp(rhs);
++++temp.swap(*this);
}|1315679|我不知道为什么它不是写成swap(temp)的，但这似乎很常见。|offset|length|style|CODE|1315680|entityMap^0|0|0|0|0|0|0|C|A|0^^$0|@$1|2|3|4|5|6|7|W|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|X|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|Y|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|Z|8|@]|9|@]|A|$E|F]]|$1|K|3|L|5|6|7|10|8|@]|9|@]|A|$]]|$1|M|3|N|5|D|7|11|8|@]|9|@]|A|$E|F]]|$1|O|3|P|5|6|7|12|8|@$Q|13|R|14|S|T]]|9|@]|A|$]]|$1|U|3|-4|5|6|7|15|8|@]|9|@]|A|$]]]|V|$]]

One other case is when invoking operators. E.g. instead of

<pre><code>bool Type::operator!=(const Type&amp; rhs)
{
 return !operator==(rhs);
}
</code></pre>

you can say

<pre><code>bool Type::operator!=(const Type&amp; rhs)
{
 return !(*this == rhs);
}
</code></pre>

Which might be more readable. Another example is the copy-and-swap:

<pre><code>Type&amp; Type::operator=(const Type&amp; rhs)
{
 Type temp(rhs);
 temp.swap(*this);
}
</code></pre>

I don't know why it's not written <code>swap(temp)</code> but this seems to be common.

blocks|key|1315757|text|虽然我通常并不特别喜欢它，但我已经看到其他人使用它->只是为了从intellisense获得帮助！|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1315758|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

Although I usually don't particular like it, I've seen others use this-> simply to get help from intellisense!

blocks|key|1530947|text|this指针的主要(或者我可以说，唯一的)用途是它指向用于调用成员函数的对象。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1530948|基于这个目的，我们可以在某些情况下只使用this指针就可以解决这个问题。|1530949|例如，我们必须返回成员函数中的调用对象，参数是同一个类对象：|1530950|class+human+{

...+

human+&+human::compare(human+&+h){
++++if+(condition)
++++++++return+h;+++++++//+argument+object
++++else+
++++++++return+*this;+++//+invoking+object
++++}
};|code-block|syntax|javascript|1530951|entityMap^0|0|4|0|K|4|0|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@$9|R|A|S|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|T|8|@$9|U|A|V|B|C]]|D|@]|E|$]]|$1|H|3|I|5|6|7|W|8|@]|D|@]|E|$]]|$1|J|3|K|5|L|7|X|8|@]|D|@]|E|$M|N]]|$1|O|3|-4|5|6|7|Y|8|@]|D|@]|E|$]]]|P|$]]

The main (or I can say, the only) purpose of <code>this</code> pointer is that it points to the object used to invoke a member function.

Base on this purpose, we can have some cases that only using <code>this</code> pointer can solve the problem.

For example, we have to return the invoking object in a member function with argument is an same class object:

<pre><code>class human {

... 

human &amp; human::compare(human &amp; h){
 if (condition)
 return h; // argument object
 else 
 return *this; // invoking object
 }
};
</code></pre>

When should I explicitly write <code>this-&gt;member</code> in a method of
a class?

When should I make explicit use of the `this` pointer?

翻译质量差，导致语言生硬或混乱。

没有提供实际的解决方法或示例。

解答不清晰，无法理解或解决问题。

页面排版不美观，阅读体验差。

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

一站式MCP教程库，解锁AI应用新玩法

什么时候应该在类的方法中显式地编写this->member？

问什么时候应该显式使用`this`指针？
EN

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问什么时候应该显式使用`this`指针？EN