除了语法糖，引用是常量指针（而不是指向常量的指针）。在声明引用变量时，必须确定它所指的内容，以后不能更改它。

更新：现在我再考虑一下，有一个重要的区别。

常量指针的目标可以通过获取其地址并使用常量转换来替换。

引用的目标不能以UB以外的任何方式替换。

这应该允许编译器对引用进行更多优化。

塔林♦ 说：

不能像使用指针那样获取引用的地址。

事实上你可以。

我引用了另一个问题的答案：

C++常见问题解答说得最好：与指针不同，一旦引用绑定到对象，就不能将其“重新放置”到另一个对象。引用本身不是一个对象（它没有标识；获取引用的地址可以获得引用的地址；记住：引用是它的引用）。

引用是另一个变量的别名，而指针保存变量的内存地址。引用通常用作函数参数，因此传递的对象不是副本而是对象本身。

    void fun(int &a, int &b); // A common usage of references.
    int a = 0;
    int &b = a; // b is an alias for a. Not so common to use. 

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

除了这里的所有答案，

可以使用引用实现运算符重载：

my_point operator+(const my_point& a, const my_point& b)
{
  return { a.x + b.x, a.y + b.y };
}

使用参数作为值将创建原始参数的临时副本，而使用指针将不会调用此函数，因为指针算法。

除非我需要以下任何一项，否则我会使用参考资料：

空指针可以用作哨兵价值，通常是一种廉价的方式避免函数重载或使用嘘声。你可以在指针上做算术。例如，p+=偏移量；