不能像指针一样取消引用，当取消引用时，

引用和指针都是通过地址工作的。。。

so

你可以这样做

int*val=0xDEADBEEF；*val是0xDEADBEEF的值。

你不能这样做int&V=1；

*不允许使用val。

为了避免混淆，我想输入一些输入，我确信这主要取决于编译器如何实现引用，但在gcc的情况下，引用只能指向堆栈上的变量的想法实际上并不正确，例如：

#include <iostream>
int main(int argc, char** argv) {
    // Create a string on the heap
    std::string *str_ptr = new std::string("THIS IS A STRING");
    // Dereference the string on the heap, and assign it to the reference
    std::string &str_ref = *str_ptr;
    // Not even a compiler warning! At least with gcc
    // Now lets try to print it's value!
    std::cout << str_ref << std::endl;
    // It works! Now lets print and compare actual memory addresses
    std::cout << str_ptr << " : " << &str_ref << std::endl;
    // Exactly the same, now remember to free the memory on the heap
    delete str_ptr;
}

其输出如下：

THIS IS A STRING
0xbb2070 : 0xbb2070

如果您注意到甚至内存地址都完全相同，这意味着引用成功地指向了堆上的一个变量！现在，如果你真的想变得古怪，这也很有效：

int main(int argc, char** argv) {
    // In the actual new declaration let immediately de-reference and assign it to the reference
    std::string &str_ref = *(new std::string("THIS IS A STRING"));
    // Once again, it works! (at least in gcc)
    std::cout << str_ref;
    // Once again it prints fine, however we have no pointer to the heap allocation, right? So how do we free the space we just ignorantly created?
    delete &str_ref;
    /*And, it works, because we are taking the memory address that the reference is
    storing, and deleting it, which is all a pointer is doing, just we have to specify
    the address with '&' whereas a pointer does that implicitly, this is sort of like
    calling delete &(*str_ptr); (which also compiles and runs fine).*/
}

其输出如下：

THIS IS A STRING

因此，引用是引擎盖下的指针，它们都只是存储一个内存地址，地址指向的位置是不相关的，如果我调用std:：cout<<str_ref；调用delete str_ref后？很明显，它编译得很好，但在运行时会导致分段错误，因为它不再指向有效变量，我们本质上有一个中断的引用仍然存在（直到它超出范围），但没有用。

换句话说，引用只是一个指针，它抽象了指针机制，使其更安全、更容易使用（没有意外的指针数学，没有混淆“.”和“->”等），假设您没有像上面的例子那样尝试任何废话；）

现在，不管编译器如何处理引用，它总是有某种指针，因为引用必须引用特定内存地址处的特定变量，才能按预期工作，因此无法绕过这一点（因此称为“引用”）。

对于引用，唯一需要记住的重要规则是必须在声明时定义它们（头中的引用除外，在这种情况下，必须在构造函数中定义引用，在构造包含引用的对象之后，再定义它就太晚了）。

请记住，我上面的例子只是说明引用是什么的例子，你永远不想以这些方式使用引用！为了正确使用参考文献，这里已经有很多答案，这些答案一针见血

引用是常量指针。int*const a=&b与int&a=b相同。这就是为什么没有const引用，因为它已经是const，而const的引用是const int*consta。当使用-O0编译时，编译器将在这两种情况下将b的地址放在堆栈上，并且作为类的成员，它也将出现在堆栈/堆上的对象中，与您声明了常量指针时相同。使用-Ofast，可以免费优化此功能。常量指针和引用都被优化了。

与常量指针不同，无法获取引用本身的地址，因为它将被解释为它引用的变量的地址。因此，在Ofast上，表示引用的常量指针（被引用变量的地址）将始终在堆栈外进行优化，但如果程序绝对需要实际常量指针的地址（指针本身的地址，而不是指针指向的地址），即您打印常量指针的位置，那么const指针将被放置在堆栈上，以便它有一个地址。

否则它是相同的，即当您打印它指向的地址时：

#include <iostream>

int main() {
  int a =1;
  int* b = &a;
  std::cout << b ;
}

int main() {
  int a =1;
  int& b = a;
  std::cout << &b ;
}

they both have the same assembly output
-Ofast:
main:
        sub     rsp, 24
        mov     edi, OFFSET FLAT:_ZSt4cout
        lea     rsi, [rsp+12]
        mov     DWORD PTR [rsp+12], 1
        call    std::basic_ostream<char, std::char_traits<char> >& std::basic_ostream<char, std::char_traits<char> >::_M_insert<void const*>(void const*)
        xor     eax, eax
        add     rsp, 24
        ret
--------------------------------------------------------------------
-O0:
main:
        push    rbp
        mov     rbp, rsp
        sub     rsp, 16
        mov     DWORD PTR [rbp-12], 1
        lea     rax, [rbp-12]
        mov     QWORD PTR [rbp-8], rax
        mov     rax, QWORD PTR [rbp-8]
        mov     rsi, rax
        mov     edi, OFFSET FLAT:_ZSt4cout
        call    std::basic_ostream<char, std::char_traits<char> >::operator<<(void const*)
        mov     eax, 0
        leave
        ret

指针已经在堆栈外进行了优化，在这两种情况下，指针甚至都没有在-Ofast上取消引用，而是使用编译时值。

作为对象的成员，它们在-O0到-Ofast上是相同的。

#include <iostream>
int b=1;
struct A {int* i=&b; int& j=b;};
A a;
int main() {
  std::cout << &a.j << &a.i;
}

The address of b is stored twice in the object. 

a:
        .quad   b
        .quad   b

        mov     rax, QWORD PTR a[rip+8] //&a.j
        mov     esi, OFFSET FLAT:a //&a.i

当通过引用传递时，在-O0上，传递被引用变量的地址，因此它与通过指针传递相同，即常量指针包含的地址。On Ofast如果函数可以内联，则编译器会在内联调用中对其进行优化，因为动态范围是已知的，但在函数定义中，参数总是作为指针（期望引用引用的变量的地址）被解引用，其中它可能被另一个转换单元使用，而编译器不知道动态范围，当然，除非函数声明为静态函数，否则它不能在转换单元之外使用，然后它通过值传递，只要它没有在函数中通过引用进行修改，那么它将传递您传递的引用所引用的变量的地址，如果调用约定中有足够多的易失性寄存器，则将在一个寄存器中传递，并保持在堆栈之外。

这是基于教程。所写内容更清楚：

>>> The address that locates a variable within memory is
    what we call a reference to that variable. (5th paragraph at page 63)

>>> The variable that stores the reference to another
    variable is what we call a pointer. (3rd paragraph at page 64)

简单地记住，

>>> reference stands for memory location
>>> pointer is a reference container (Maybe because we will use it for
several times, it is better to remember that reference.)

此外，我们可以参考几乎任何指针教程，指针是指针算术支持的对象，它使指针类似于数组。

看看下面的陈述，

int Tom(0);
int & alias_Tom = Tom;

alias_Tom可以理解为变量的别名（与typedef不同，typedef是一种类型的别名）Tom。忘记这种说法的术语也是可以的，即创建一个对汤姆的引用。

我总是根据C++核心指南中的这条规则来决定：

当“无参数”是有效选项时，优先选择T*而不是T&

我对引用和指针有一个类比，将引用看作对象的另一个名称，将指针看作对象的地址。

// receives an alias of an int, an address of an int and an int value
public void my_function(int& a,int* b,int c){
    int d = 1; // declares an integer named d
    int &e = d; // declares that e is an alias of d
    // using either d or e will yield the same result as d and e name the same object
    int *f = e; // invalid, you are trying to place an object in an address
    // imagine writting your name in an address field 
    int *g = f; // writes an address to an address
    g = &d; // &d means get me the address of the object named d you could also
    // use &e as it is an alias of d and write it on g, which is an address so it's ok
}