不同之处在于，非常量指针变量（不要与指向常量的指针混淆）可能会在程序执行过程中的某个时间发生更改，需要使用指针语义（&，*）运算符，而引用只能在初始化时设置（这就是为什么您只能在构造函数初始化器列表中设置它们，但不能以其他方式设置它们），并使用普通值访问语义。基本上，引用是为了支持运算符重载而引入的，正如我在一些非常古老的书中所读到的那样。正如有人在这个线程中所说的，指针可以设置为0或任何您想要的值。0（NULL，nullptr）表示指针初始化为空。取消引用空指针是错误的。但实际上，指针可能包含一个不指向某个正确内存位置的值。反过来，引用试图不允许用户初始化对某个无法引用的对象的引用，因为您总是向其提供正确类型的右值。尽管有很多方法可以将引用变量初始化到错误的内存位置，但最好不要深入了解细节。在机器级，指针和参考都通过指针统一工作。让我们假设在基本参考中是句法糖。rvalue引用与此不同，它们自然是堆栈/堆对象。

与流行观点相反，引用可能为NULL。

int * p = NULL;
int & r = *p;
r = 1;  // crash! (if you're lucky)

当然，使用引用要困难得多，但如果你管理它，你会为了找到它而绞尽脑汁。引用在C++中并不安全！

从技术上讲，这是一个无效引用，而不是空引用。C++不支持在其他语言中可能会发现的空引用作为概念。还有其他类型的无效引用。任何无效引用都会引发未定义行为的幽灵，就像使用无效指针一样。

实际错误是在分配给引用之前取消引用NULL指针。但我不知道任何编译器会在这种情况下生成任何错误——错误会传播到代码中更远的地方。这就是这个问题如此阴险的原因。大多数情况下，如果取消引用NULL指针，就会在该位置崩溃，而且不需要太多调试就可以解决问题。

我上面的例子简短而做作。这是一个更真实的例子。

class MyClass
{
    ...
    virtual void DoSomething(int,int,int,int,int);
};

void Foo(const MyClass & bar)
{
    ...
    bar.DoSomething(i1,i2,i3,i4,i5);  // crash occurs here due to memory access violation - obvious why?
}

MyClass * GetInstance()
{
    if (somecondition)
        return NULL;
    ...
}

MyClass * p = GetInstance();
Foo(*p);

我想重申，获得空引用的唯一方法是通过格式错误的代码，一旦获得了它，就会得到未定义的行为。检查空引用是没有意义的；例如，您可以尝试如果（&bar==NULL）。。。但是编译器可能会优化不存在的语句！有效引用永远不能为NULL，因此从编译器的角度来看，比较总是错误的，并且可以自由地将if子句作为死代码来消除-这是未定义行为的本质。

避免麻烦的正确方法是避免取消引用NULL指针来创建引用。这里有一种自动化的方法来实现这一点。

template<typename T>
T& deref(T* p)
{
    if (p == NULL)
        throw std::invalid_argument(std::string("NULL reference"));
    return *p;
}

MyClass * p = GetInstance();
Foo(deref(p));

要从具有更好写作技巧的人那里了解这个问题，请参阅Jim Hyslop和Herb Sutter的空引用。

有关取消引用空指针的危险的另一个示例，请参见Raymond Chen在尝试将代码移植到另一个平台时暴露未定义的行为。

也许一些隐喻会有所帮助；在桌面屏幕空间中-

引用要求您指定实际窗口。指针需要屏幕上一块空间的位置，确保它将包含该窗口类型的零个或多个实例。

另一个区别是，可以有指向void类型的指针（这意味着指向任何对象的指针），但禁止引用void。

int a;
void * p = &a; // ok
void & p = a;  //  forbidden

我不能说我真的很满意这种特殊的差异。我更希望它能被允许有意义地引用任何有地址的东西，否则引用行为相同。它将允许使用引用定义一些C库函数的等价物，如memcpy。

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

它占用多少空间并不重要，因为你实际上看不到它占用的任何空间的任何副作用（不执行代码）。

另一方面，引用和指针之间的一个主要区别是，分配给常量引用的临时变量在常量引用超出范围之前一直有效。

例如：

class scope_test
{
public:
    ~scope_test() { printf("scope_test done!\n"); }
};

...

{
    const scope_test &test= scope_test();
    printf("in scope\n");
}

将打印：

in scope
scope_test done!

这是允许ScopeGuard工作的语言机制。