指针是保存另一个变量的内存地址的变量，其中引用是现有变量的别名。（已存在变量的另一个名称）

1.指针可以初始化为：

int b = 15;
int *q = &b;

OR

int *q;
q = &b;

其中作为参考，

int b=15;
int &c=b;

（在一个步骤中声明和初始化）

指针可以分配给null，但引用不能可以对指针执行各种算术运算，而没有所谓的参考算术。指针可以重新分配，但引用不能指针在堆栈上有自己的内存地址和大小，而引用共享相同的内存地址

与流行观点相反，引用可能为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 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. 

我觉得还有一点还没有在这里讨论。

与指针不同，引用在语法上等同于它们所引用的对象，即可以应用于对象的任何操作都适用于引用，并且具有完全相同的语法（当然，初始化是例外）。

虽然这可能看起来很肤浅，但我认为这一特性对于一些C++特性来说至关重要，例如：

模板。因为模板参数是鸭子类型的，所以类型的语法财产才是最重要的，所以通常同一个模板可以同时用于T和T&。（或std:：reference_wrapper＜T＞，它仍然依赖于隐式转换至T&）覆盖T&和T&&的模板更为常见。L值。考虑语句str[0]=“X”；如果没有引用，它只适用于c字符串（char*str）。通过引用返回字符允许用户定义的类具有相同的符号。复制构造函数。从语法上讲，将对象传递给复制构造函数是有意义的，而不是传递给对象的指针。但复制构造函数无法按值获取对象，这将导致对同一复制构造函数的递归调用。这将引用作为此处的唯一选项。操作员过载。通过引用，可以在保留相同的中缀符号的同时，将间接指向引入运算符调用，例如运算符+（const T&a，const T&b）。这也适用于常规重载函数。

这些点赋予了C++和标准库相当大的一部分权力，因此这是参考文献的一个重要属性。

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

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

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

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，而不是引用本身。赋值后，两个引用仍然引用其原始对象，并且这些对象的值现在也相同。