将指针视为名片：

它让你有机会联系某人它可以是empy它可能包含错误或过时的信息你不确定上面提到的某人还活着你不能直接与卡片通话，你只能用它打电话给某人也许有很多这样的卡片

将推荐人视为与某人的主动通话：

你很确定你联系过的人还活着您可以直接通话，无需额外通话你很确定你不会和一个空地方或一块垃圾说话你不能确定你是唯一一个当前正在与此对象交谈的人

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

// 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
}

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

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

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. 

除非我需要以下任何一项，否则我会使用参考资料：

空指针可以用作哨兵价值，通常是一种廉价的方式避免函数重载或使用嘘声。你可以在指针上做算术。例如，p+=偏移量；

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

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

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