实际上，引用并不像指针。

编译器保持对变量的“引用”，将名称与内存地址相关联；这是编译时将任何变量名转换为内存地址的工作。

创建引用时，只告诉编译器为指针变量指定了另一个名称；这就是为什么引用不能“指向null”，因为变量不能是，也不能是。

指针是变量；它们包含其他变量的地址，或者可以为空。重要的是指针有一个值，而引用只有一个引用的变量。

现在对真实代码进行一些解释：

int a = 0;
int& b = a;

在这里，您没有创建另一个指向；您只需将另一个名称添加到内存内容中，该内存内容的值为a。该内存现在有两个名称，a和b，可以使用任一名称对其进行寻址。

void increment(int& n)
{
    n = n + 1;
}

int a;
increment(a);

当调用函数时，编译器通常为要复制到的参数生成内存空间。函数签名定义了应该创建的空间，并给出了应该用于这些空间的名称。将参数声明为引用只是告诉编译器使用输入变量内存空间，而不是在方法调用期间分配新的内存空间。说你的函数将直接操作在调用作用域中声明的变量似乎很奇怪，但请记住，在执行编译代码时，没有更多的作用域；只有普通的平面内存，函数代码可以处理任何变量。

现在，在某些情况下，编译器在编译时可能无法知道引用，例如使用外部变量时。因此，在底层代码中，引用可以实现为指针，也可以不实现为指针。但在我给你的例子中，它很可能不会用指针实现。

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

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

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

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

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

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

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+=偏移量；

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

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