将指针视为名片：

它让你有机会联系某人它可以是empy它可能包含错误或过时的信息你不确定上面提到的某人还活着你不能直接与卡片通话，你只能用它打电话给某人也许有很多这样的卡片

将推荐人视为与某人的主动通话：

你很确定你联系过的人还活着您可以直接通话，无需额外通话你很确定你不会和一个空地方或一块垃圾说话你不能确定你是唯一一个当前正在与此对象交谈的人

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

    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超出范围。

我觉得还有一点还没有在这里讨论。

与指针不同，引用在语法上等同于它们所引用的对象，即可以应用于对象的任何操作都适用于引用，并且具有完全相同的语法（当然，初始化是例外）。

虽然这可能看起来很肤浅，但我认为这一特性对于一些C++特性来说至关重要，例如：

模板。因为模板参数是鸭子类型的，所以类型的语法财产才是最重要的，所以通常同一个模板可以同时用于T和T&。（或std:：reference_wrapper＜T＞，它仍然依赖于隐式转换至T&）覆盖T&和T&&的模板更为常见。L值。考虑语句str[0]=“X”；如果没有引用，它只适用于c字符串（char*str）。通过引用返回字符允许用户定义的类具有相同的符号。复制构造函数。从语法上讲，将对象传递给复制构造函数是有意义的，而不是传递给对象的指针。但复制构造函数无法按值获取对象，这将导致对同一复制构造函数的递归调用。这将引用作为此处的唯一选项。操作员过载。通过引用，可以在保留相同的中缀符号的同时，将间接指向引入运算符调用，例如运算符+（const T&a，const T&b）。这也适用于常规重载函数。

这些点赋予了C++和标准库相当大的一部分权力，因此这是参考文献的一个重要属性。

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

>>> 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++参考（针对C程序员）

引用可以被视为具有自动间接寻址的常量指针（不要与指向常量值的指针混淆！），即编译器将为您应用*运算符。

所有引用都必须使用非空值初始化，否则编译将失败。既不可能获得引用的地址——地址运算符将返回被引用值的地址——也不可能对引用进行算术运算。

C程序员可能不喜欢C++引用，因为当发生间接寻址时，或者当参数通过值或指针传递而不查看函数签名时，C++引用将不再明显。

C++程序员可能不喜欢使用指针，因为它们被认为是不安全的——尽管引用实际上并不比常量指针更安全，但在大多数情况下除外——缺乏自动间接寻址的便利性，并且具有不同的语义内涵。

考虑C++常见问题解答中的以下语句：

即使引用通常使用底层汇编语言，请不要将引用视为指向对象的有趣指针。引用是对象。它是不是指向对象的指针，也不是对象的副本。它是对象

但如果引用真的是对象，那么怎么会有悬空引用呢？在非托管语言中，引用不可能比指针更“安全”——通常没有办法跨范围可靠地别名值！

为什么我认为C++引用有用

来自C背景的C++引用可能看起来有点傻，但在可能的情况下，仍应使用它们而不是指针：自动间接寻址很方便，在处理RAII时引用变得特别有用，但这并不是因为任何已知的安全优势，而是因为它们使编写惯用代码不那么困难。

RAII是C++的核心概念之一，但它与复制语义进行了非平凡的交互。通过引用传递对象可以避免这些问题，因为不需要复制。如果语言中没有引用，则必须使用指针，这样使用起来更麻烦，从而违反了语言设计原则，即最佳实践解决方案应该比替代方案更容易。