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

// 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
}

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

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

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

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

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

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

引用永远不能为NULL。

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

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

如果遵循传递给函数的参数的约定，则可以使用引用和指针之间的差异。Const引用用于传递到函数中的数据，指针用于传递出函数的数据。在其他语言中，您可以使用诸如In和out之类的关键字来明确表示这一点。在C++中，您可以（按照约定）声明等价的。例如

void DoSomething(const Foo& thisIsAnInput, Foo* thisIsAnOutput)
{
   if (thisIsAnOuput)
      *thisIsAnOutput = thisIsAnInput;
}

使用引用作为输入和指针作为输出是Google风格指南的一部分。