这个程序可能有助于理解问题的答案。这是一个引用“j”和指向变量“x”的指针“ptr”的简单程序。

#include<iostream>

using namespace std;

int main()
{
int *ptr=0, x=9; // pointer and variable declaration
ptr=&x; // pointer to variable "x"
int & j=x; // reference declaration; reference to variable "x"

cout << "x=" << x << endl;

cout << "&x=" << &x << endl;

cout << "j=" << j << endl;

cout << "&j=" << &j << endl;

cout << "*ptr=" << *ptr << endl;

cout << "ptr=" << ptr << endl;

cout << "&ptr=" << &ptr << endl;
    getch();
}

运行程序并查看输出，您就会明白。

另外，抽出10分钟观看以下视频：https://www.youtube.com/watch?v=rlJrrGV0iOg

你忘记了最重要的部分：

带指针的成员访问使用->使用引用的成员访问。

foo.bar明显优于foo->bar，就像vi明显优于Emacs一样：-）

可以重新分配指针：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&更便于在参数列表等中使用。

简言之

指针：指针是保存另一个变量的内存地址的变量。指针需要使用*运算符解引用以访问它所指向的内存位置。-摘自Geeks for Geeks

引用：引用变量是别名，即现有变量的另一个名称。引用（如指针）也通过存储对象的地址来实现。-摘自极客对极客

另一张图片了解更多详情：

在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;
}

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

指针

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

工具书类

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

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

文章

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

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