如果你不熟悉以抽象的甚至学术的方式学习计算机语言，那么语义上的差异可能会显得深奥难懂。

在最高级别上，引用的概念是它们是透明的“别名”。你的计算机可能会使用一个地址来使它们工作，但你不必担心：你应该将它们视为现有对象的“另一个名称”，语法反映了这一点。它们比指针更严格，因此编译器可以在您将要创建悬挂引用时比在您将创建悬挂指针时更可靠地警告您。

除此之外，指针和引用之间当然还有一些实际差异。使用它们的语法明显不同，您不能“重新定位”引用、引用虚无或引用指针。

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

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

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

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

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

可以重新分配指针：int x=5；整数y=6；int*p；p＝&x；p=&y；*p=10；断言（x==5）；断言（y==10）；引用不能重新绑定，必须在初始化时绑定：int x=5；整数y=6；整数&q；//错误int&r=x；指针变量有它自己的标识：一个独特的、可见的内存地址，可以用一元&运算符获取，还有一定的空间，可以用sizeof运算符测量。对引用使用这些运算符将返回与引用绑定到的任何对象相对应的值；引用自身的地址和大小是不可见的。由于引用以这种方式假定原始变量的身份，因此可以方便地将引用视为同一变量的另一个名称。int x=0；int&r=x；int*p=&x；int*p2=&r；断言（p==p2）；//&x==&r断言（&p！=&p2）；可以将任意嵌套的指针指向提供额外间接级别的指针。引用仅提供一个间接级别。int x=0；整数y=0；int*p=&x；int*q=&y；int**pp=&p；**pp=2；pp=&q；//*pp现在是q**pp=4；断言（y==4）；断言（x==2）；指针可以指定为nullptr，而引用必须绑定到现有对象。如果您足够努力，您可以将引用绑定到nullptr，但这是未定义的，并且行为不一致。/*以下代码未定义；你的编译器可以优化它*不同的是，发出警告，或者干脆拒绝编译*/int&r=*static_cast<int*>（nullptr）；//在GCC 10下打印“空”标准：：cout<<（&r！=空指针? “not null”：“null”）<<std:：endl；bool f（int&r）｛return&r！=nullptr；｝//根据GCC 10打印“非空”标准：：cout<<（f（*static_cast<int*>（nullptr））? “not null”：“null”）<<std:：endl；但是，可以引用值为nullptr的指针。指针可以遍历数组；您可以使用++转到指针指向的下一个项目，使用+4转到第五个元素。这与指针指向的对象的大小无关。指针需要用*解引用以访问它指向的内存位置，而引用可以直接使用。指向类/结构的指针使用->访问其成员，而引用使用。。引用不能放入数组，而指针可以（由用户@litb提及）Const引用可以绑定到临时项。指针不能（不是没有间接指向）：常量int&x=int（12）；//法定C++int*y=&int（12）；//取临时地址是非法的。这使得const&更便于在参数列表等中使用。

我总是根据C++核心指南中的这条规则来决定：

当“无参数”是有效选项时，优先选择T*而不是T&

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

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

例如：

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

引用的另一个有趣用法是提供用户定义类型的默认参数：

class UDT
{
public:
   UDT() : val_d(33) {};
   UDT(int val) : val_d(val) {};
   virtual ~UDT() {};
private:
   int val_d;
};

class UDT_Derived : public UDT
{
public:
   UDT_Derived() : UDT() {};
   virtual ~UDT_Derived() {};
};

class Behavior
{
public:
   Behavior(
      const UDT &udt = UDT()
   )  {};
};

int main()
{
   Behavior b; // take default

   UDT u(88);
   Behavior c(u);

   UDT_Derived ud;
   Behavior d(ud);

   return 1;
}

默认风格使用引用的“bind const reference to a temporary”方面。