blocks|key|1116193|text|引用的自然实现确实是一个指针。但是，不要在代码中依赖这一点。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1116194|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|$]]

<p>The natural implementation of a reference is indeed a pointer. However, do not depend on this in your code.</p>


blocks|key|901434|text|为了重复大家一直在说的一些东西，让我们来看看一些编译器输出：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|901435|#include+<stdio.h>
#include+<stdlib.h>

int+byref(int+&+foo)
{
++printf("%25d\n",+foo);
}
int+byptr(int+*+foo)
{
++printf("%25d\n",+*foo);
}

int+main(int+argc,+char+**argv)+{
++int+aFoo+=+5;+
++byref(aFoo);
++byptr(&aFoo);
}|code-block|syntax|javascript|901436|我们可以使用LLVM进行编译(关闭优化)，并得到以下结果：|901437|define+i32+@_Z5byrefRi(i32*+%25foo)+{
entry:
++%25foo_addr+=+alloca+i32*+++++++++++++++++++++++++;+<i32**>+[#uses=2]
++%25retval+=+alloca+i32++++++++++++++++++++++++++++;+<i32*>+[#uses=1]
++%25"alloca+point"+=+bitcast+i32+0+to+i32++++++++++;+<i32>+[#uses=0]
++store+i32*+%25foo,+i32**+%25foo_addr
++%250+=+load+i32**+%25foo_addr,+align+8++++++++++++++;+<i32*>+[#uses=1]
++%251+=+load+i32*+%250,+align+4++++++++++++++++++++++;+<i32>+[#uses=1]
++%252+=+call+i32+(i8*,+...)*+@printf(i8*+noalias+getelementptr+inbounds+([4+x+i8]*+@.str,+i64+0,+i64+0),+i32+%251)+;+<i32>+[#uses=0]
++br+label+%25return

return:+++++++++++++++++++++++++++++++++++++++++++;+preds+=+%25entry
++%25retval1+=+load+i32*+%25retval++++++++++++++++++++;+<i32>+[#uses=1]
++ret+i32+%25retval1
}

define+i32+@_Z5byptrPi(i32*+%25foo)+{
entry:
++%25foo_addr+=+alloca+i32*+++++++++++++++++++++++++;+<i32**>+[#uses=2]
++%25retval+=+alloca+i32++++++++++++++++++++++++++++;+<i32*>+[#uses=1]
++%25"alloca+point"+=+bitcast+i32+0+to+i32++++++++++;+<i32>+[#uses=0]
++store+i32*+%25foo,+i32**+%25foo_addr
++%250+=+load+i32**+%25foo_addr,+align+8++++++++++++++;+<i32*>+[#uses=1]
++%251+=+load+i32*+%250,+align+4++++++++++++++++++++++;+<i32>+[#uses=1]
++%252+=+call+i32+(i8*,+...)*+@printf(i8*+noalias+getelementptr+inbounds+([4+x+i8]*+@.str,+i64+0,+i64+0),+i32+%251)+;+<i32>+[#uses=0]
++br+label+%25return

return:+++++++++++++++++++++++++++++++++++++++++++;+preds+=+%25entry
++%25retval1+=+load+i32*+%25retval++++++++++++++++++++;+<i32>+[#uses=1]
++ret+i32+%25retval1
}|901438|这两个函数的主体是相同的|901439|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|D|7|R|8|@]|9|@]|A|$E|F]]|$1|K|3|L|5|6|7|S|8|@]|9|@]|A|$]]|$1|M|3|-4|5|6|7|T|8|@]|9|@]|A|$]]]|N|$]]

<p>Just to repeat some of the stuff everyone's been saying, lets look at some compiler output:</p>

<pre><code>#include &lt;stdio.h&gt;
#include &lt;stdlib.h&gt;

int byref(int &amp; foo)
{
  printf("%d\n", foo);
}
int byptr(int * foo)
{
  printf("%d\n", *foo);
}

int main(int argc, char **argv) {
  int aFoo = 5; 
  byref(aFoo);
  byptr(&amp;aFoo);
}
</code></pre>

<p>We can compile this with LLVM (with optimizations turned off) and we get the following:</p>

<pre><code>define i32 @_Z5byrefRi(i32* %foo) {
entry:
  %foo_addr = alloca i32*                         ; &lt;i32**&gt; [#uses=2]
  %retval = alloca i32                            ; &lt;i32*&gt; [#uses=1]
  %"alloca point" = bitcast i32 0 to i32          ; &lt;i32&gt; [#uses=0]
  store i32* %foo, i32** %foo_addr
  %0 = load i32** %foo_addr, align 8              ; &lt;i32*&gt; [#uses=1]
  %1 = load i32* %0, align 4                      ; &lt;i32&gt; [#uses=1]
  %2 = call i32 (i8*, ...)* @printf(i8* noalias getelementptr inbounds ([4 x i8]* @.str, i64 0, i64 0), i32 %1) ; &lt;i32&gt; [#uses=0]
  br label %return

return:                                           ; preds = %entry
  %retval1 = load i32* %retval                    ; &lt;i32&gt; [#uses=1]
  ret i32 %retval1
}

define i32 @_Z5byptrPi(i32* %foo) {
entry:
  %foo_addr = alloca i32*                         ; &lt;i32**&gt; [#uses=2]
  %retval = alloca i32                            ; &lt;i32*&gt; [#uses=1]
  %"alloca point" = bitcast i32 0 to i32          ; &lt;i32&gt; [#uses=0]
  store i32* %foo, i32** %foo_addr
  %0 = load i32** %foo_addr, align 8              ; &lt;i32*&gt; [#uses=1]
  %1 = load i32* %0, align 4                      ; &lt;i32&gt; [#uses=1]
  %2 = call i32 (i8*, ...)* @printf(i8* noalias getelementptr inbounds ([4 x i8]* @.str, i64 0, i64 0), i32 %1) ; &lt;i32&gt; [#uses=0]
  br label %return

return:                                           ; preds = %entry
  %retval1 = load i32* %retval                    ; &lt;i32&gt; [#uses=1]
  ret i32 %retval1
}
</code></pre>

<p>The bodies of both functions are identical</p>


blocks|key|1116284|text|引用不是指针。这是事实。指针可以绑定到另一个对象，具有自己的操作，如解引用和递增/递减。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1116285|尽管在内部，引用也可以实现为指针。但这是一个实现细节，并没有改变引用不能与指针互换的事实。假设引用是作为指针实现的，那么就不能编写代码。|1116286|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|F|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|G|8|@]|9|@]|A|$]]|$1|D|3|-4|5|6|7|H|8|@]|9|@]|A|$]]]|E|$]]

<p>Reference is not pointer. This is fact. Pointer can bind to another object, has its own operations like dereferencing and incrementing / decrementing.</p>

<p>Although internally, reference may be implemented as a pointer. But this is an implementation detail which does not change the fact that references cannot be interchanged with pointers. And one cannot write code assuming references are implemented as pointers.</p>


blocks|key|901589|text|很抱歉使用汇编来解释这一点，但我认为这是理解编译器如何实现引用的最好方法。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|901590|++++#include+<iostream>

++++using+namespace+std;

++++int+main()
++++{
++++++++int+i+=+10;
++++++++int+*ptrToI+=+&i;
++++++++int+&refToI+=+i;

++++++++cout+<<+"i+=+"+<<+i+<<+"\n";
++++++++cout+<<+"&i+=+"+<<+&i+<<+"\n";

++++++++cout+<<+"ptrToI+=+"+<<+ptrToI+<<+"\n";
++++++++cout+<<+"*ptrToI+=+"+<<+*ptrToI+<<+"\n";
++++++++cout+<<+"&ptrToI+=+"+<<+&ptrToI+<<+"\n";

++++++++cout+<<+"refToNum+=+"+<<+refToI+<<+"\n";
++++++++//cout+<<+"*refToNum+=+"+<<+*refToI+<<+"\n";
++++++++cout+<<+"&refToNum+=+"+<<+&refToI+<<+"\n";

++++++++return+0;
++++}|code-block|syntax|javascript|901591|此代码的输出如下所示|901592|++++i+=+10
++++&i+=+0xbf9e52f8
++++ptrToI+=+0xbf9e52f8
++++*ptrToI+=+10
++++&ptrToI+=+0xbf9e52f4
++++refToNum+=+10
++++&refToNum+=+0xbf9e52f8|901593|让我们看一下反汇编(我使用GDB来做这件事。8、9和10是代码的行号)|901594|8+++++++++++int+i+=+10;
0x08048698+<main()%2B18>:+movl+++$0xa,-0x10(%25ebp)|901595|这里，$0xa是我们分配给i的10(十进制)。这里的-0x10(%25ebp)指的是ebp+register+-16(十进制)的内容。-0x10(%25ebp)指向堆栈上i的地址。|offset|length|style|CODE|901596|9+++++++++++int+*ptrToI+=+&i;
0x0804869f+<main()%2B25>:+lea++++-0x10(%25ebp),%25eax
0x080486a2+<main()%2B28>:+mov++++%25eax,-0x14(%25ebp)|901597|将i地址分配给ptrToI。ptrToI再次位于地址-0x14(%25ebp)处的堆栈上，即ebp+-20(十进制)。|901598|10++++++++++int+&refToI+=+i;
0x080486a5+<main()%2B31>:+lea++++-0x10(%25ebp),%25eax
0x080486a8+<main()%2B34>:+mov++++%25eax,-0xc(%25ebp)|901599|这就是问题所在！比较第9行和第10行的反汇编，您将看到，第10行中的-0x14(%25ebp)替换为-0xc(%25ebp)。-0xc(%25ebp)是refToNum的地址。它在堆栈上分配。但是你永远不能从你的代码中得到这个地址，因为你不需要知道地址。|901600|因此，引用确实会占用内存。在本例中，它是堆栈内存，因为我们已将其分配为局部变量。它占用了多少内存？和指针占用的空间一样多。|901601|现在让我们看看如何访问引用和指针。为简单起见，我只展示了程序集片段的一部分|901602|16++++++++++cout+<<+"*ptrToI+=+"+<<+*ptrToI+<<+"\n";
0x08048746+<main()%2B192>:++++++++mov++++-0x14(%25ebp),%25eax
0x08048749+<main()%2B195>:++++++++mov++++(%25eax),%25ebx
19++++++++++cout+<<+"refToNum+=+"+<<+refToI+<<+"\n";
0x080487b0+<main()%2B298>:++++++++mov++++-0xc(%25ebp),%25eax
0x080487b3+<main()%2B301>:++++++++mov++++(%25eax),%25ebx|901603|现在比较上面两行，你会看到惊人的相似之处。-0xc(%25ebp)是refToI的实际地址，您永远无法访问它。简而言之，如果你认为引用是一个普通的指针，那么访问引用就像是在引用指向的地址取值。这意味着下面两行代码会给出相同的结果|901604|cout+<<+"Value+if+i+=+"+<<+*ptrToI+<<+"\n";
cout+<<+"+Value+if+i+=+"+<<+refToI+<<+"\n";|901605|现在比较一下这个|901606|15++++++++++cout+<<+"ptrToI+=+"+<<+ptrToI+<<+"\n";
0x08048713+<main()%2B141>:++++++++mov++++-0x14(%25ebp),%25ebx
21++++++++++cout+<<+"&refToNum+=+"+<<+&refToI+<<+"\n";
0x080487fb+<main()%2B373>:++++++++mov++++-0xc(%25ebp),%25eax|901607|我猜你能看出来这里发生了什么。如果您请求&refToI，则返回-0xc(%25ebp)+address+location的内容，-0xc(%25ebp)是refToi所在的位置，它的内容只是i的地址。|901608|最后一件事，为什么这一行是注释的？|901609|//cout+<<+"*refToNum+=+"+<<+*refToI+<<+"\n";|901610|因为*refToI是不允许的，它会给你一个编译时错误。|901611|entityMap^0|0|0|0|0|0|0|3|4|D|1|Q|B|14|C|1T|B|29|1|0|0|1|1|7|6|E|6|Q|B|18|3|0|0|Y|B|1C|A|1N|A|1Y|8|0|0|0|0|L|A|W|6|0|0|0|0|K|7|V|A|1Q|A|21|6|2J|1|0|0|0|2|7|0^^$0|@$1|2|3|4|5|6|7|1Q|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|1R|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|1S|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|1T|8|@]|9|@]|A|$E|F]]|$1|K|3|L|5|6|7|1U|8|@]|9|@]|A|$]]|$1|M|3|N|5|D|7|1V|8|@]|9|@]|A|$E|F]]|$1|O|3|P|5|6|7|1W|8|@$Q|1X|R|1Y|S|T]|$Q|1Z|R|20|S|T]|$Q|21|R|22|S|T]|$Q|23|R|24|S|T]|$Q|25|R|26|S|T]|$Q|27|R|28|S|T]]|9|@]|A|$]]|$1|U|3|V|5|D|7|29|8|@]|9|@]|A|$E|F]]|$1|W|3|X|5|6|7|2A|8|@$Q|2B|R|2C|S|T]|$Q|2D|R|2E|S|T]|$Q|2F|R|2G|S|T]|$Q|2H|R|2I|S|T]|$Q|2J|R|2K|S|T]]|9|@]|A|$]]|$1|Y|3|Z|5|D|7|2L|8|@]|9|@]|A|$E|F]]|$1|10|3|11|5|6|7|2M|8|@$Q|2N|R|2O|S|T]|$Q|2P|R|2Q|S|T]|$Q|2R|R|2S|S|T]|$Q|2T|R|2U|S|T]]|9|@]|A|$]]|$1|12|3|13|5|6|7|2V|8|@]|9|@]|A|$]]|$1|14|3|15|5|6|7|2W|8|@]|9|@]|A|$]]|$1|16|3|17|5|D|7|2X|8|@]|9|@]|A|$E|F]]|$1|18|3|19|5|6|7|2Y|8|@$Q|2Z|R|30|S|T]|$Q|31|R|32|S|T]]|9|@]|A|$]]|$1|1A|3|1B|5|D|7|33|8|@]|9|@]|A|$E|F]]|$1|1C|3|1D|5|6|7|34|8|@]|9|@]|A|$]]|$1|1E|3|1F|5|D|7|35|8|@]|9|@]|A|$E|F]]|$1|1G|3|1H|5|6|7|36|8|@$Q|37|R|38|S|T]|$Q|39|R|3A|S|T]|$Q|3B|R|3C|S|T]|$Q|3D|R|3E|S|T]|$Q|3F|R|3G|S|T]]|9|@]|A|$]]|$1|1I|3|1J|5|6|7|3H|8|@]|9|@]|A|$]]|$1|1K|3|1L|5|D|7|3I|8|@]|9|@]|A|$E|F]]|$1|1M|3|1N|5|6|7|3J|8|@$Q|3K|R|3L|S|T]]|9|@]|A|$]]|$1|1O|3|-4|5|6|7|3M|8|@]|9|@]|A|$]]]|1P|$]]

<p>Sorry for using assembly to explain this but I think this is the best way to understand how references are implemented by compilers. </p>

<pre><code>    #include &lt;iostream&gt;

    using namespace std;

    int main()
    {
        int i = 10;
        int *ptrToI = &amp;i;
        int &amp;refToI = i;

        cout &lt;&lt; "i = " &lt;&lt; i &lt;&lt; "\n";
        cout &lt;&lt; "&amp;i = " &lt;&lt; &amp;i &lt;&lt; "\n";

        cout &lt;&lt; "ptrToI = " &lt;&lt; ptrToI &lt;&lt; "\n";
        cout &lt;&lt; "*ptrToI = " &lt;&lt; *ptrToI &lt;&lt; "\n";
        cout &lt;&lt; "&amp;ptrToI = " &lt;&lt; &amp;ptrToI &lt;&lt; "\n";

        cout &lt;&lt; "refToNum = " &lt;&lt; refToI &lt;&lt; "\n";
        //cout &lt;&lt; "*refToNum = " &lt;&lt; *refToI &lt;&lt; "\n";
        cout &lt;&lt; "&amp;refToNum = " &lt;&lt; &amp;refToI &lt;&lt; "\n";

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

<p>Output of this code is like this </p>

<pre><code>    i = 10
    &amp;i = 0xbf9e52f8
    ptrToI = 0xbf9e52f8
    *ptrToI = 10
    &amp;ptrToI = 0xbf9e52f4
    refToNum = 10
    &amp;refToNum = 0xbf9e52f8
</code></pre>

<p>Lets look at the disassembly(I used GDB for this. 8,9 and 10 here are line numbers of code)</p>

<pre><code>8           int i = 10;
0x08048698 &lt;main()+18&gt;: movl   $0xa,-0x10(%ebp)
</code></pre>

<p>Here <code>$0xa</code> is the 10(decimal) that we are assigning to <code>i</code>. <code>-0x10(%ebp)</code> here means content of <code>ebp register</code> –16(decimal). 
<code>-0x10(%ebp)</code> points to the address of <code>i</code> on stack.</p>

<pre><code>9           int *ptrToI = &amp;i;
0x0804869f &lt;main()+25&gt;: lea    -0x10(%ebp),%eax
0x080486a2 &lt;main()+28&gt;: mov    %eax,-0x14(%ebp)
</code></pre>

<p>Assign address of <code>i</code> to <code>ptrToI</code>. <code>ptrToI</code> is again on stack located at address <code>-0x14(%ebp)</code>, that is <code>ebp</code> – 20(decimal).</p>

<pre><code>10          int &amp;refToI = i;
0x080486a5 &lt;main()+31&gt;: lea    -0x10(%ebp),%eax
0x080486a8 &lt;main()+34&gt;: mov    %eax,-0xc(%ebp)
</code></pre>

<p>Now here is the catch! Compare disassembly of line 9 and 10 and you will observer that ,<code>-0x14(%ebp)</code> is replaced by <code>-0xc(%ebp)</code> in line number 10. <code>-0xc(%ebp)</code> is the address of <code>refToNum</code>. It is allocated on stack. But you will never be able to get this address from you code because you are not required to know the address.</p>

<p>So; a reference does occupy memory. In this case it is the stack memory since we have allocated it as a local variable. 
How much memory does it occupy?
 As much a pointer occupies.</p>

<p>Now lets see how we access the reference and pointers. For simplicity I have shown only part of the assembly snippet </p>

<pre><code>16          cout &lt;&lt; "*ptrToI = " &lt;&lt; *ptrToI &lt;&lt; "\n";
0x08048746 &lt;main()+192&gt;:        mov    -0x14(%ebp),%eax
0x08048749 &lt;main()+195&gt;:        mov    (%eax),%ebx
19          cout &lt;&lt; "refToNum = " &lt;&lt; refToI &lt;&lt; "\n";
0x080487b0 &lt;main()+298&gt;:        mov    -0xc(%ebp),%eax
0x080487b3 &lt;main()+301&gt;:        mov    (%eax),%ebx
</code></pre>

<p>Now compare the above two lines, you will see striking similarity.  <code>-0xc(%ebp)</code> is the actual address of <code>refToI</code> which is never accessible to you. 
In simple terms, if you think of reference as a normal pointer, then accessing a reference is like fetching the value at address pointed to by the reference. Which means the below two lines of code will give you the same result</p>

<pre><code>cout &lt;&lt; "Value if i = " &lt;&lt; *ptrToI &lt;&lt; "\n";
cout &lt;&lt; " Value if i = " &lt;&lt; refToI &lt;&lt; "\n";
</code></pre>

<p>Now compare this</p>

<pre><code>15          cout &lt;&lt; "ptrToI = " &lt;&lt; ptrToI &lt;&lt; "\n";
0x08048713 &lt;main()+141&gt;:        mov    -0x14(%ebp),%ebx
21          cout &lt;&lt; "&amp;refToNum = " &lt;&lt; &amp;refToI &lt;&lt; "\n";
0x080487fb &lt;main()+373&gt;:        mov    -0xc(%ebp),%eax
</code></pre>

<p>I guess you are able to spot what is happening here. 
If you ask for <code>&amp;refToI</code>, the contents of  <code>-0xc(%ebp)</code> address location are returned and <code>-0xc(%ebp)</code> is where <code>refToi</code> resides and its contents are nothing but address of <code>i</code>. </p>

<p>One last thing, Why is this line commented?</p>

<pre><code>//cout &lt;&lt; "*refToNum = " &lt;&lt; *refToI &lt;&lt; "\n";
</code></pre>

<p>Because <code>*refToI</code> is not permitted and it will give you a compile time error. </p>


blocks|key|901689|text|不需要引用就能成为指针。在许多情况下，它是，但在其他情况下，它只是一个别名，并且不需要为指针单独分配内存。汇编示例并不总是正确的，因为它们在很大程度上依赖于优化和编译器的“智能”程度。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|901690|例如:+int+i；int&+j=+i；|901691|不需要生成任何额外的代码或分配任何额外的内存。|901692|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|H|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|I|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|J|8|@]|9|@]|A|$]]|$1|F|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|G|$]]

<p>There is no need a reference to be a pointer.
In many cases, it is, but in other cases it is just an alias and there is no need of separate memory allocation for a pointer.
assembly samples are not always correct, because they depend heavily on optimizations and how "smart" is the compiler. </p>

<p>for example:
int i;
int&amp; j = i;</p>

<p>does not need to generate any additional code or allocate any additional memory.</p>


<p>I'm just wondering how references are actually implemented across different compilers and debug/release configurations. Does the standard provide recommendations on their implementation? Do implementations differ?</p>

<p>I tried to run a simple program where I return non-const references and pointers to local variables from functions, but they worked out the same way. Does this mean that references are internally just a pointer?</p>


How are references implemented internally?

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

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

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

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

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

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

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

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

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

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

我只是想知道引用是如何在不同的编译器和调试/发布配置中实现的。该标准是否提供了关于其实现的建议？实现方式是否有所不同？我试着运行一个简单的程序，从函数返回非常数引用和指向局部变量的指针，但它们的工作方式是一样的。这是否意味着引用在内部只是一个指针？

问引用是如何在内部实现的？
EN

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问引用是如何在内部实现的？EN

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问引用是如何在内部实现的？
EN