引用永远不能为NULL。

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

>>> 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。忘记这种说法的术语也是可以的，即创建一个对汤姆的引用。

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

    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. 

关于引用和指针的一些关键相关细节

指针

使用一元后缀声明符运算符声明指针变量*指针对象被分配一个地址值，例如，通过分配给数组对象、使用一元前缀运算符的对象地址或分配给另一个指针对象的值指针可以重新分配任意次数，指向不同的对象指针是保存指定地址的变量。它占用的内存存储量等于目标机器体系结构的地址大小例如，可以通过增量或加法运算符对指针进行数学操作。因此，可以使用指针等进行迭代。要获取或设置指针引用的对象的内容，必须使用一元前缀运算符*来取消引用它

工具书类

引用在声明时必须初始化。引用使用一元后缀声明符运算符&声明。初始化引用时，可以使用它们将直接引用的对象的名称，而不需要一元前缀运算符&一旦初始化，引用就不能通过赋值或算术操作指向其他对象无需取消引用该引用以获取或设置其引用的对象的内容对引用的赋值操作操作它指向的对象的内容（初始化后），而不是引用本身（不改变它指向的位置）对引用的算术运算操作它指向的对象的内容，而不是引用本身（不会改变它指向的位置）在几乎所有的实现中，引用实际上都存储为被引用对象的内存中的地址。因此，它占用的内存大小与目标机器体系结构的地址大小相同，就像指针对象一样

尽管指针和引用的实现方式几乎相同，但编译器对它们的处理方式不同，导致了上述所有差异。

文章

我最近写的一篇文章比我在这里展示的要详细得多，对这个问题非常有帮助，特别是关于记忆中的事情是如何发生的：

数组、指针和引擎罩下的引用深度文章

引用与指针非常相似，但它们是专门设计的，有助于优化编译器。

引用的设计使得编译器更容易跟踪哪些引用别名哪些变量。两个主要特性非常重要：没有“引用算术”，也没有重新分配引用。这些允许编译器在编译时找出哪些引用别名哪些变量。允许引用没有内存地址的变量，例如编译器选择放入寄存器的变量。如果获取局部变量的地址，编译器很难将其放入寄存器中。

例如：

void maybeModify(int& x); // may modify x in some way

void hurtTheCompilersOptimizer(short size, int array[])
{
    // This function is designed to do something particularly troublesome
    // for optimizers. It will constantly call maybeModify on array[0] while
    // adding array[1] to array[2]..array[size-1]. There's no real reason to
    // do this, other than to demonstrate the power of references.
    for (int i = 2; i < (int)size; i++) {
        maybeModify(array[0]);
        array[i] += array[1];
    }
}

优化编译器可能会意识到，我们正在访问一个[0]和一个[1]。它希望优化算法以：

void hurtTheCompilersOptimizer(short size, int array[])
{
    // Do the same thing as above, but instead of accessing array[1]
    // all the time, access it once and store the result in a register,
    // which is much faster to do arithmetic with.
    register int a0 = a[0];
    register int a1 = a[1]; // access a[1] once
    for (int i = 2; i < (int)size; i++) {
        maybeModify(a0); // Give maybeModify a reference to a register
        array[i] += a1;  // Use the saved register value over and over
    }
    a[0] = a0; // Store the modified a[0] back into the array
}

要进行这样的优化，需要证明在调用期间没有任何东西可以改变数组[1]。这很容易做到。i永远不小于2，所以array[i]永远不能引用array[1]。maybeModify（）被给定a0作为引用（别名数组[0]）。因为没有“引用”算法，编译器只需要证明maybeModify永远不会得到x的地址，并且它已经证明没有任何东西会改变数组[1]。

它还必须证明，当我们在a0中有一个[0]的临时寄存器副本时，将来的调用不可能读/写它。这通常很难证明，因为在许多情况下，引用显然从未存储在类实例这样的永久结构中。

现在用指针做同样的事情

void maybeModify(int* x); // May modify x in some way

void hurtTheCompilersOptimizer(short size, int array[])
{
    // Same operation, only now with pointers, making the
    // optimization trickier.
    for (int i = 2; i < (int)size; i++) {
        maybeModify(&(array[0]));
        array[i] += array[1];
    }
}

行为是相同的；直到现在，要证明maybeModify从未修改过数组[1]要困难得多，因为我们已经给了它一个指针；猫从袋子里出来了。现在它必须做更困难的证明：对maybeModify进行静态分析，以证明它从未写入&x+1。它还必须证明它从未保存过可以引用数组[0]的指针，这同样棘手。

现代编译器在静态分析方面越来越好，但帮助他们并使用引用总是很好的。

当然，除非进行这种巧妙的优化，编译器确实会在需要时将引用转换为指针。

编辑：在发布这个答案五年后，我发现了一个实际的技术差异，即引用不同于看待相同寻址概念的不同方式。引用可以以指针无法修改的方式修改临时对象的寿命。

F createF(int argument);

void extending()
{
    const F& ref = createF(5);
    std::cout << ref.getArgument() << std::endl;
};

通常，临时对象（例如通过调用createF（5）创建的对象）会在表达式末尾被销毁。然而，通过将该对象绑定到引用ref，C++将延长该临时对象的寿命，直到ref超出范围。

引用永远不能为NULL。