引用永远不能为NULL。

塔林♦ 说：

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

事实上你可以。

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

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

如果你真的想变得迂腐，有一件事你可以用指针做，但不能用指针做：延长临时对象的生命周期。在C++中，如果将常量引用绑定到临时对象，则该对象的生存期将变为引用的生存期。

std::string s1 = "123";
std::string s2 = "456";

std::string s3_copy = s1 + s2;
const std::string& s3_reference = s1 + s2;

在本例中，s3_copy复制连接后的临时对象。而s3_reference本质上成为临时对象。它实际上是对临时对象的引用，该对象现在与引用具有相同的生存期。

如果您尝试在没有常量的情况下执行此操作，它将无法编译。不能将非常量引用绑定到临时对象，也不能为此获取其地址。

与流行观点相反，引用可能为NULL。

int * p = NULL;
int & r = *p;
r = 1;  // crash! (if you're lucky)

当然，使用引用要困难得多，但如果你管理它，你会为了找到它而绞尽脑汁。引用在C++中并不安全！

从技术上讲，这是一个无效引用，而不是空引用。C++不支持在其他语言中可能会发现的空引用作为概念。还有其他类型的无效引用。任何无效引用都会引发未定义行为的幽灵，就像使用无效指针一样。

实际错误是在分配给引用之前取消引用NULL指针。但我不知道任何编译器会在这种情况下生成任何错误——错误会传播到代码中更远的地方。这就是这个问题如此阴险的原因。大多数情况下，如果取消引用NULL指针，就会在该位置崩溃，而且不需要太多调试就可以解决问题。

我上面的例子简短而做作。这是一个更真实的例子。

class MyClass
{
    ...
    virtual void DoSomething(int,int,int,int,int);
};

void Foo(const MyClass & bar)
{
    ...
    bar.DoSomething(i1,i2,i3,i4,i5);  // crash occurs here due to memory access violation - obvious why?
}

MyClass * GetInstance()
{
    if (somecondition)
        return NULL;
    ...
}

MyClass * p = GetInstance();
Foo(*p);

我想重申，获得空引用的唯一方法是通过格式错误的代码，一旦获得了它，就会得到未定义的行为。检查空引用是没有意义的；例如，您可以尝试如果（&bar==NULL）。。。但是编译器可能会优化不存在的语句！有效引用永远不能为NULL，因此从编译器的角度来看，比较总是错误的，并且可以自由地将if子句作为死代码来消除-这是未定义行为的本质。

避免麻烦的正确方法是避免取消引用NULL指针来创建引用。这里有一种自动化的方法来实现这一点。

template<typename T>
T& deref(T* p)
{
    if (p == NULL)
        throw std::invalid_argument(std::string("NULL reference"));
    return *p;
}

MyClass * p = GetInstance();
Foo(deref(p));

要从具有更好写作技巧的人那里了解这个问题，请参阅Jim Hyslop和Herb Sutter的空引用。

有关取消引用空指针的危险的另一个示例，请参见Raymond Chen在尝试将代码移植到另一个平台时暴露未定义的行为。

此外，作为内联函数的参数的引用的处理方式可能与指针不同。

void increment(int *ptrint) { (*ptrint)++; }
void increment(int &refint) { refint++; }
void incptrtest()
{
    int testptr=0;
    increment(&testptr);
}
void increftest()
{
    int testref=0;
    increment(testref);
}

许多编译器在内联指针版本1时实际上会强制写入内存（我们显式地获取地址）。然而，他们会将引用保留在更优化的寄存器中。

当然，对于未内联的函数，指针和引用生成相同的代码，如果函数未修改和返回内部函数，则通过值传递内部函数总是比通过引用传递内部函数更好。

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