以下答案和链接的摘要：

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

澄清误解：

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

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

作为一般规则，

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

有趣的阅读：

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

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

    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. 

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

指针

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

工具书类

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

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

文章

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

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

我对引用和指针有一个类比，将引用看作对象的另一个名称，将指针看作对象的地址。

// receives an alias of an int, an address of an int and an int value
public void my_function(int& a,int* b,int c){
    int d = 1; // declares an integer named d
    int &e = d; // declares that e is an alias of d
    // using either d or e will yield the same result as d and e name the same object
    int *f = e; // invalid, you are trying to place an object in an address
    // imagine writting your name in an address field 
    int *g = f; // writes an address to an address
    g = &d; // &d means get me the address of the object named d you could also
    // use &e as it is an alias of d and write it on g, which is an address so it's ok
}

虽然引用和指针都用于间接访问另一个值，但引用和指针之间有两个重要的区别。第一个是引用总是引用一个对象：在没有初始化引用的情况下定义引用是错误的。赋值行为是第二个重要区别：赋值给引用会更改引用绑定的对象；它不会将引用重新绑定到另一个对象。初始化后，引用始终引用同一基础对象。

考虑这两个程序片段。首先，我们将一个指针分配给另一个指针：

int ival = 1024, ival2 = 2048;
int *pi = &ival, *pi2 = &ival2;
pi = pi2;    // pi now points to ival2

在赋值ival之后，pi所寻址的对象保持不变。赋值会更改pi的值，使其指向不同的对象。现在考虑一个分配两个引用的类似程序：

int &ri = ival, &ri2 = ival2;
ri = ri2;    // assigns ival2 to ival

此赋值更改了ri引用的值ival，而不是引用本身。赋值后，两个引用仍然引用其原始对象，并且这些对象的值现在也相同。

在C++中，对指针的引用是可能的，但反之则不可能，这意味着指向引用的指针是不可能的。对指针的引用提供了一种更简洁的语法来修改指针。看看这个例子：

#include<iostream>
using namespace std;

void swap(char * &str1, char * &str2)
{
  char *temp = str1;
  str1 = str2;
  str2 = temp;
}

int main()
{
  char *str1 = "Hi";
  char *str2 = "Hello";
  swap(str1, str2);
  cout<<"str1 is "<<str1<<endl;
  cout<<"str2 is "<<str2<<endl;
  return 0;
}

并考虑上述程序的C版本。在C语言中，你必须使用指针对指针（多重间接寻址），这会导致混乱，程序可能看起来很复杂。

#include<stdio.h>
/* Swaps strings by swapping pointers */
void swap1(char **str1_ptr, char **str2_ptr)
{
  char *temp = *str1_ptr;
  *str1_ptr = *str2_ptr;
  *str2_ptr = temp;
}

int main()
{
  char *str1 = "Hi";
  char *str2 = "Hello";
  swap1(&str1, &str2);
  printf("str1 is %s, str2 is %s", str1, str2);
  return 0;
}

有关指针引用的详细信息，请访问以下内容：

C++：指针引用指向指针的指针和指向指针的引用

正如我所说，指向引用的指针是不可能的。尝试以下程序：

#include <iostream>
using namespace std;

int main()
{
   int x = 10;
   int *ptr = &x;
   int &*ptr1 = ptr;
}