以下答案和链接的摘要：

指针可以被重新分配任意次数，而引用在绑定后不能被重新分配。指针可以指向任何地方（NULL），而引用总是指向对象。不能像使用指针那样获取引用的地址。没有“引用算术”（但您可以获取引用指向的对象的地址，并对其进行指针算术，如&obj+5中所示）。

澄清误解：

C++标准非常小心，避免规定编译器如何实现引用，但每个C++编译器都实现引用作为指针。即，声明如下：int&ri=i；如果没有完全优化，则分配相同数量的存储作为指针，并放置地址把我的东西放进那个储藏室。

因此，指针和引用都使用相同的内存量。

作为一般规则，

使用函数参数和返回类型中的引用来提供有用的自记录接口。使用指针实现算法和数据结构。

有趣的阅读：

我最喜欢的C++常见问题解答。参考与指针。参考文献简介。参考和常量。

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

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

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

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

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

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

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”方面。

指针和引用之间有一个根本的区别，我没有看到任何人提到过：引用支持函数参数中的引用传递语义。指针，虽然它最初不可见，但它不可见：它们只提供值传递语义。这在本文中得到了很好的描述。

当做&rzej公司

“我知道引用是语法糖，所以代码更容易读写”

这引用不是实现指针的另一种方式，尽管它涵盖了大量的指针用例。指针是一种数据类型——通常指向实际值的地址。然而，它可以设置为零，或者使用地址算术等设置在地址之后的几个位置。对于具有自己值的变量，引用是“语法糖”。

C只有传递值语义。获取变量引用的数据的地址并将其发送到函数是一种通过“引用”传递的方法。引用通过“引用”原始数据位置本身在语义上简化了这一过程。因此：

int x = 1;
int *y = &x;
int &z = x;

Y是一个int指针，指向存储x的位置。X和Z表示相同的存储位置（堆栈或堆）。

很多人谈论过这两个（指针和引用）之间的区别，好像它们是同一个东西，用法不同一样。它们完全不同。

1） “指针可以被重新分配任意次数，而引用在绑定后不能被重新分配。”--指针是指向数据的地址数据类型。引用是数据的另一个名称。因此，您可以“重新分配”引用。你不能重新分配它所指的数据位置。就像你不能更改“x”所指的位置一样，你也不能更改“z”。

x = 2;
*y = 2;
z = 2;

相同的。这是一次重新分配。

2） “指针不能指向任何地方（NULL），而引用总是指向对象”——同样令人困惑。引用只是对象的另一个名称。空指针表示（语义上）它没有引用任何内容，而引用是通过表示它是“x”的另一个名称来创建的。自从

3） “你不能像用指针那样获取引用的地址”——是的，你可以。再次带着困惑。如果您试图查找用作引用的指针的地址，这是一个问题——因为引用不是指向对象的指针。他们就是目标。所以你可以得到对象的地址，也可以得到指针的地址。因为它们都在获取数据的地址（一个是对象在内存中的位置，另一个是指向对象在内存位置的指针）。

int *yz = &z; -- legal
int **yy = &y; -- legal

int *yx = &x; -- legal; notice how this looks like the z example.  x and z are equivalent.

4） “这里没有“引用算术”——同样有点混淆——因为上面的例子中z是对x的引用，因此两者都是整数，所以“引用”算术意味着例如将x引用的值加1。

x++;
z++;

*y++;  // what people assume is happening behind the scenes, but isn't. it would produce the same results in this example.
*(y++);  // this one adds to the pointer, and then dereferences it.  It makes sense that a pointer datatype (an address) can be incremented.  Just like an int can be incremented. 

指针和引用之间有一个非常重要的非技术性区别：通过指针传递给函数的参数比通过非常量引用传递给函数参数的参数更为可见。例如：

void fn1(std::string s);
void fn2(const std::string& s);
void fn3(std::string& s);
void fn4(std::string* s);

void bar() {
    std::string x;
    fn1(x);  // Cannot modify x
    fn2(x);  // Cannot modify x (without const_cast)
    fn3(x);  // CAN modify x!
    fn4(&x); // Can modify x (but is obvious about it)
}

回到C中，一个看起来像fn（x）的调用只能通过值传递，因此它肯定不能修改x；要修改参数，需要传递指针fn（&x）。所以，如果一个参数前面没有&，你就知道它不会被修改。（相反，&表示已修改，这是不正确的，因为有时必须通过常量指针传递大型只读结构。）

一些人认为，这是读取代码时非常有用的特性，指针参数应该始终用于可修改的参数，而不是非常量引用，即使函数从不期望null指针。也就是说，这些人认为不应该允许像上面的fn3（）这样的函数签名。谷歌的C++风格指南就是一个例子。