除了这里的所有答案，

可以使用引用实现运算符重载：

my_point operator+(const my_point& a, const my_point& b)
{
  return { a.x + b.x, a.y + b.y };
}

使用参数作为值将创建原始参数的临时副本，而使用指针将不会调用此函数，因为指针算法。

除了语法糖，引用是常量指针（而不是指向常量的指针）。在声明引用变量时，必须确定它所指的内容，以后不能更改它。

更新：现在我再考虑一下，有一个重要的区别。

常量指针的目标可以通过获取其地址并使用常量转换来替换。

引用的目标不能以UB以外的任何方式替换。

这应该允许编译器对引用进行更多优化。

不能像指针一样取消引用，当取消引用时，

引用和指针都是通过地址工作的。。。

so

你可以这样做

int*val=0xDEADBEEF；*val是0xDEADBEEF的值。

你不能这样做int&V=1；

*不允许使用val。

引用永远不能为NULL。

指针和引用之间有一个非常重要的非技术性区别：通过指针传递给函数的参数比通过非常量引用传递给函数参数的参数更为可见。例如：

void fn1(std::string s);
void fn2(const std::string& s);
void fn3(std::string& s);
void fn4(std::string* s);

void bar() {
    std::string x;
    fn1(x);  // Cannot modify x
    fn2(x);  // Cannot modify x (without const_cast)
    fn3(x);  // CAN modify x!
    fn4(&x); // Can modify x (but is obvious about it)
}

回到C中，一个看起来像fn（x）的调用只能通过值传递，因此它肯定不能修改x；要修改参数，需要传递指针fn（&x）。所以，如果一个参数前面没有&，你就知道它不会被修改。（相反，&表示已修改，这是不正确的，因为有时必须通过常量指针传递大型只读结构。）

一些人认为，这是读取代码时非常有用的特性，指针参数应该始终用于可修改的参数，而不是非常量引用，即使函数从不期望null指针。也就是说，这些人认为不应该允许像上面的fn3（）这样的函数签名。谷歌的C++风格指南就是一个例子。

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

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