blocks|key|1332882|text|最简单的方法是将this看作是一个始终自动传递的隐藏的额外参数。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1332883|因此，一个虚构的方法如下：|1332884|size_t+String::length(void)+const
{
++return+strlen(m_string);
}|code-block|syntax|javascript|1332885|实际上更像是这样的：|1332886|size_t+String__length(const+String+*this)
{
++return+strlen(this->m_string);
}|1332887|和一个类似这样的调用：|1332888|{
++String+example("hello");
++cout+<<+example.length();
}|1332889|变得类似于：|1332890|cout+<<+String__length(&example);|1332891|请注意，上面的转换被简化了，希望能让我的观点更清晰一点。不需要在注释中填上“哇，方法重载的编组在哪里？”-type反对。:)|1332892|这就将问题转化为“参数存储在哪里？”，答案当然是“视情况而定”。:)|1332893|它通常在堆栈上，但也可以在寄存器中，或者编译器认为对目标体系结构有利的任何其他机制中。|1332894|entityMap^0|8|4|0|0|0|0|0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|16|8|@$9|17|A|18|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|19|8|@]|D|@]|E|$]]|$1|H|3|I|5|J|7|1A|8|@]|D|@]|E|$K|L]]|$1|M|3|N|5|6|7|1B|8|@]|D|@]|E|$]]|$1|O|3|P|5|J|7|1C|8|@]|D|@]|E|$K|L]]|$1|Q|3|R|5|6|7|1D|8|@]|D|@]|E|$]]|$1|S|3|T|5|J|7|1E|8|@]|D|@]|E|$K|L]]|$1|U|3|V|5|6|7|1F|8|@]|D|@]|E|$]]|$1|W|3|X|5|J|7|1G|8|@]|D|@]|E|$K|L]]|$1|Y|3|Z|5|6|7|1H|8|@]|D|@]|E|$]]|$1|10|3|11|5|6|7|1I|8|@]|D|@]|E|$]]|$1|12|3|13|5|6|7|1J|8|@]|D|@]|E|$]]|$1|14|3|-4|5|6|7|1K|8|@]|D|@]|E|$]]]|15|$]]

The easiest way is to think of <code>this</code> as being a hidden extra argument that is always passed automatically.

So, a fictional method like:

<pre><code>size_t String::length(void) const
{
 return strlen(m_string);
}
</code></pre>

is actually more like this under the hood:

<pre><code>size_t String__length(const String *this)
{
 return strlen(this-&gt;m_string);
}
</code></pre>

and a call like:

<pre><code>{
 String example("hello");
 cout &lt;&lt; example.length();
}
</code></pre>

becomes something like:

<pre><code>cout &lt;&lt; String__length(&amp;example);
</code></pre>

Note that the above transformation is simplified, hopefully to make my point a bit clearer. No need to fill up the comments with "whaaa, where's the marshalling for method overloading, huh?"-type objection, please. :)

That transforms the question into "where are arguments stored?", and the answer is of course "it depends". :)

It's often on the stack, but it could be in registers too, or any other mechanism that the compiler considers is good for the target architecture.

blocks|key|1492130|text|this的行为在很大程度上类似于函数参数，因此将存储在堆栈中，或者-如果体系结构的二进制调用约定允许的话-存储在寄存器中。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1492131|entityMap^0|0|4|0^^$0|@$1|2|3|4|5|6|7|H|8|@$9|I|A|J|B|C]]|D|@]|E|$]]|$1|F|3|-4|5|6|7|K|8|@]|D|@]|E|$]]]|G|$]]

<code>this</code> behaves mostly like a function argument, and as such will be stored on the stack or - if the binary calling conventions of the architecture allow that - in a register.

blocks|key|349479|text|this通常作为方法的隐藏参数传递(不同调用约定中唯一的区别是如何传递)。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|349480|如果你打电话给：|349481|myClass.Method(1,+2,+3);|code-block|syntax|javascript|349482|编译器生成以下代码：|349483|Method(&myClass,+1,+2,+3);|349484|其中第一个参数实际上是指向this的指针。|349485|让我们检查一下以下代码：|349486|class+MyClass
{
private:
++++int+a;

public:
++++void+__stdcall+Method(int+i)
++++{
++++++++a+=+i;
++++}
};

int+main(int+argc,+char+*argv[])+
{
++++MyClass+myClass;
++++myClass.Method(5);

++++return+0;
}|349487|通过使用__stdcall，我强制编译器通过堆栈传递所有参数。如果您随后启动调试器并检查汇编代码，您将发现类似以下内容：|349488|+++++myClass.Method(5);
00AA31BE++push++++++++5++
00AA31C0++lea+++++++++eax,[myClass]++
00AA31C3++push++++++++eax++
00AA31C4++call++++++++MyClass::Method+(0AA1447h)++|349489|如您所见，该方法的参数通过堆栈传递，然后将myClass的地址加载到eax寄存器并再次推送到堆栈上。换句话说，this被视为此方法的常规参数。|349490|entityMap^0|0|4|0|0|0|0|0|D|4|0|0|0|4|9|0|0|1J|4|0^^$0|@$1|2|3|4|5|6|7|14|8|@$9|15|A|16|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|17|8|@]|D|@]|E|$]]|$1|H|3|I|5|J|7|18|8|@]|D|@]|E|$K|L]]|$1|M|3|N|5|6|7|19|8|@]|D|@]|E|$]]|$1|O|3|P|5|J|7|1A|8|@]|D|@]|E|$K|L]]|$1|Q|3|R|5|6|7|1B|8|@$9|1C|A|1D|B|C]]|D|@]|E|$]]|$1|S|3|T|5|6|7|1E|8|@]|D|@]|E|$]]|$1|U|3|V|5|J|7|1F|8|@]|D|@]|E|$K|L]]|$1|W|3|X|5|6|7|1G|8|@$9|1H|A|1I|B|C]]|D|@]|E|$]]|$1|Y|3|Z|5|J|7|1J|8|@]|D|@]|E|$K|L]]|$1|10|3|11|5|6|7|1K|8|@$9|1L|A|1M|B|C]]|D|@]|E|$]]|$1|12|3|-4|5|6|7|1N|8|@]|D|@]|E|$]]]|13|$]]

<code>this</code> is usually passed as a hidden argument of the method (the only difference throughout different calling conventions is how).

If you call:

<pre><code>myClass.Method(1, 2, 3);
</code></pre>

Compiler generates the following code:

<pre><code>Method(&amp;myClass, 1, 2, 3);
</code></pre>

Where the first parameter is actually the pointer to <code>this</code>.

Let's check the following code:

<pre><code>class MyClass
{
private:
 int a;

public:
 void __stdcall Method(int i)
 {
 a = i;
 }
};

int main(int argc, char *argv[]) 
{
 MyClass myClass;
 myClass.Method(5);

 return 0;
}
</code></pre>

By using <code>__stdcall</code> I forced the compiler to pass all parameters through the stack. If you then start the debugger and inspect the assembly code, you'll find something like the following:

<pre class="lang-none prettyprint-override"><code> myClass.Method(5);
00AA31BE push 5 
00AA31C0 lea eax,[myClass] 
00AA31C3 push eax 
00AA31C4 call MyClass::Method (0AA1447h) 
</code></pre>

As you see, the parameter of the method is passed through the stack, then address of myClass is loaded to eax register and again pushed on the stack. In other words, <code>this</code> is treated as a regular parameter of this method.

blocks|key|1489573|text|this是一个右值(您不能获取它的地址)，所以它根本不占用内存。根据编译器和目标架构的不同，优化器通常位于一个寄存器中:+Sparc上的i0、英特尔上使用MSVC的ECX等等。当优化器处于活动状态时，它甚至可以四处移动。(我在MSVC的不同寄存器中看到过它)。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1489574|entityMap^0|0|4|0^^$0|@$1|2|3|4|5|6|7|H|8|@$9|I|A|J|B|C]]|D|@]|E|$]]|$1|F|3|-4|5|6|7|K|8|@]|D|@]|E|$]]]|G|$]]

<code>this</code> is an rvalue (you cannot take its address), so it doesn't
(necessarily) occupy memory at all. Depending on the compiler
and the target architecture, it will often be in a register: i0
on a Sparc, ECX with MSVC on Intel, etc. When the optimizer is
active, it can even move around. (I've seen it in different
registers with MSVC).

blocks|key|349055|text|this没有存储在定义良好的位置！它所指向的对象存储在某个地方，并且具有明确定义的地址，但地址本身没有特定的家庭地址。它在程序中被传递。不仅如此，该指针还可以有许多副本。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|349056|在下面虚构的init函数中，对象注册自身以接收事件和计时器回调(使用虚构的事件源对象)。因此，在注册之后，将有两个额外的this副本|349057|void+foo_listener::init()
{
+++g_usb_events.register(this);+//+register+to+receive+USB+events
+++g_timer.register(this,+5);+++//+register+for+a+5+second+timer
}|code-block|syntax|javascript|349058|在函数激活链中，也会有this指针的多个副本.假设我们有一个对象obj并调用它的foo函数。该函数调用同一对象的bar函数，而bar调用另一个名为update的函数。每个函数激活级别都有this指针。它存储在机器寄存器中，或者存储在函数激活的堆栈框架中的内存位置。|349059|entityMap^0|0|4|0|6|4|1O|4|0|0|W|3|14|3|1K|3|1R|3|21|6|2L|4|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]|$9|W|A|X|B|C]]|D|@]|E|$]]|$1|H|3|I|5|J|7|Y|8|@]|D|@]|E|$K|L]]|$1|M|3|N|5|6|7|Z|8|@$9|10|A|11|B|C]|$9|12|A|13|B|C]|$9|14|A|15|B|C]|$9|16|A|17|B|C]|$9|18|A|19|B|C]|$9|1A|A|1B|B|C]]|D|@]|E|$]]|$1|O|3|-4|5|6|7|1C|8|@]|D|@]|E|$]]]|P|$]]

<code>this</code> isn't stored at a well-defined location! The object that it points to is stored somewhere, and has a well-defined address, but the address itself does not have a specific home address. It is communicated around in the program. Not only that, but there can be many copies of that pointer.

In the following imaginary <code>init</code> function, the object registers itself to receive events and timer callbacks (using imaginary event source objects). So after the registration, there are two additional copies of <code>this</code>:

<pre><code>void foo_listener::init()
{
 g_usb_events.register(this); // register to receive USB events
 g_timer.register(this, 5); // register for a 5 second timer
}
</code></pre>

I a function activation chain, there will also be multiple copies of the this pointer. Suppose we have an object <code>obj</code> and call its <code>foo</code> function. That function calls the same object's <code>bar</code> function, and <code>bar</code> calls another function called <code>update</code>. Each function activation level has the <code>this</code> pointer. It's stored in a machine register, or in a memory location in the stack frame of the function activation.

blocks|key|3458490|text|其他答案很好地解释了典型的编译器如何实现this+(通过将其作为隐式的第一个参数传递给函数)。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|3458491|我认为看看C%2B%2B+ISO规范明确说明了这一点也很有用。根据C%2B%2B03+ISO规范，§9.3.2/1：|3458492|3458493|在非静态(9.3)成员函数体中，关键字this是一个非左值表达式，其值是为其调用函数的对象的地址。|blockquote|3458494|3458495|3458496|需要注意的是，this+is+不是一个变量-它是一个表达式，就像表达式1+%2B+2+*+3是一个表达式一样。这个表达式的值被允许存储在几乎任何地方。编译器可能会将它放到堆栈中，并将其作为隐式参数传递给函数，或者它可能会将它放在寄存器中，并且可以想象它会将它放入堆或数据段中。在这里，C%2B%2B规范有意地为实现提供了一些灵活性。|3458497|我认为“语言律师”的答案是“这是完全由实现定义的，而且从技术上讲，this不是一个指针，而是一个计算结果为指针的表达式。”|3458498|希望这能有所帮助！|3458499|entityMap^0|K|4|0|0|0|J|4|0|0|0|7|4|Z|9|0|X|4|0|0^^$0|@$1|2|3|4|5|6|7|V|8|@$9|W|A|X|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|Y|8|@]|D|@]|E|$]]|$1|H|3|-4|5|6|7|Z|8|@]|D|@]|E|$]]|$1|I|3|J|5|K|7|10|8|@$9|11|A|12|B|C]]|D|@]|E|$]]|$1|L|3|-4|5|6|7|13|8|@]|D|@]|E|$]]|$1|M|3|-4|5|6|7|14|8|@]|D|@]|E|$]]|$1|N|3|O|5|6|7|15|8|@$9|16|A|17|B|C]|$9|18|A|19|B|C]]|D|@]|E|$]]|$1|P|3|Q|5|6|7|1A|8|@$9|1B|A|1C|B|C]]|D|@]|E|$]]|$1|R|3|S|5|6|7|1D|8|@]|D|@]|E|$]]|$1|T|3|-4|5|6|7|1E|8|@]|D|@]|E|$]]]|U|$]]

Other answers have done a very good job explaining how a typical compiler implements <code>this</code> (by passing it as an implicit first parameter to the function).

I think it's also useful to see what the C++ ISO spec explicitly says about this. According to the C++03 ISO spec, &sect;9.3.2/1:

<blockquote>
 In the body of a nonstatic (9.3) member function, the keyword <code>this</code> is a non-lvalue expression whose value is the address of the object for which the function is called.
</blockquote>

It's important to note that <code>this</code> is not a variable - it's an expression, much in the same way that the expression <code>1 + 2 * 3</code> is an expression. The value of this expression is permitted to be stored pretty much anywhere. The compiler might put it on the stack and pass it as an implicit parameter to a function, or it might put it in a register, and it conceivably could put it in the heap or in the data segment. The C++ specification deliberately gives the implementation some flexibility here.

I think that the "language-lawyer" answer is "this is completely implementation-defined, and moreover <code>this</code> is technically not a pointer, but an expression that evaluates to a pointer."

Hope this helps!

Where exactly is the 'this' pointer stored in memory? Is it allocated on the stack, in the heap, or in the data segment?

<pre><code>#include &lt;iostream&gt;
using namespace std;

class ClassA
{
 int a, b;

 public:
 void add()
 {
 a = 10;
 b = 20;
 cout &lt;&lt; a &lt;&lt; b &lt;&lt; endl;
 }
};

int main()
{
 ClassA obj;
 obj.add();
 return 0;
}
</code></pre>

In the above code I am calling the member function <code>add()</code> and the receiver object is passed implicitly as the 'this' pointer. Where is <code>this</code> stored in memory?

Where is the 'this' pointer stored in computer memory?

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

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

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

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

文章

问答

视频

教程

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

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

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

腾讯云数据库专区

腾讯云智能顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

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

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

聚焦“写作效率、视觉美观与运行性能”三方面进行全面升级，为您提供更高效、稳定的创作环境

社区富文本&Markdown编辑器全新改版上线，欢迎大家体验!

诚挚邀请您参与本次调研，分享您的真实使用感受与建议。您的反馈至关重要，感谢您的支持与参与！

社区新版编辑器体验调研

“this”指针存储在内存中的确切位置？它是在堆栈上、堆中还是数据段中分配的？#include <iostream>using namespace std;class ClassA{ int a, b; public: void add() { a = 10...

问'this‘指针存储在计算机内存中的什么地方？
EN

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问'this‘指针存储在计算机内存中的什么地方？EN