引用：&(reference)与间接引用：*(dereference)

1.  符号 &(reference)，表示".....的地址"("address of")，因此称为地址操作符(adress operator)，又称引用操作符(reference operator)。例如：

foo = &myvar;

将变量myvar的地址赋给变量foo，因为当在变量名称myvar 前面加ampersand (&) 符号，foo指的将不再是该变量的内容，而是它在内存中的地址。在程序运行之前，变量的内存地址是不可知的，但为了便于理解，我们假设myvar的内存地址是1776。然后我们看下列代码：

myvar = 25;

foo = &myvar;

bar = myvar;

各自变量的存储值如下图所示：

存储其它变量地址的变量(如上面例子中的foo )，我们称之为指针(pointer)。在C++ 中，指针pointers 有其特定的优点，因此经常被使用。在后面我们将会看到这种变量如何被声明。

2.  符号 *(dereference)，表示".....所指向的值"("value pointed to by")，看下面的声明:

baz = *foo;

可以读作：baz等于foo所指向的值。baz的值变为25，因为foo存储的是内存地址1776，而*foo指的是内存地址1776指向的值，即25。

注意加或不加星号*的不同(下面代码中注释显示了如何读这两个不同的表达式):

beth = ted; // beth 等于 ted ( 1776 )

beth = *ted; // beth 等于 ted 所指向的数值 ( 25 )

3. 引用在函数中的使用

#include <iostream>
using namespace std;

int addition (int a, int b)
{
  int r;
  r=a+b;
  return r;
}

int main ()
{
  int x=5, y=3, z;
  z = addition (x,y); 
  cout << "The result is " << z;//The result is 8

}

上面的函数 addition 有两个参数int a 和 int b，这两个参数都是通过值(by value)传递的。它的意思是，当调用函数 addition(x, y) 的时候，x 和 y 的值(5 和 3)会被 copy 一份，然后分别赋值给 a 和 b。在函数内部修改 a 和 b 的值，并不会对外部的 x 和 y 造成影响。

但有时候，需要在函数内部修改外部的变量，怎么办呢？为了实现这个需求，可以通过引用(by reference)传参。看下面的例子

// passing parameters by reference
#include <iostream>
using namespace std;

void duplicate (int& a, int& b, int& c)
{
  a*=2;
  b*=2;
  c*=2;
}

int main ()
{
  int x=1, y=3, z=7;
  duplicate (x, y, z);
  cout << "x=" << x << ", y=" << y << ", z=" << z; //x=2, y=6, z=14
  return 0;
}

通过在参数类型后面添加符号 &，函数 duplicate 的三个参数都声明成了引用。当变量 x ，y，z 以引用的方式传入函数 duplicate 时，实际传入的不再是变量的值的拷贝，而是变量自己。由此，在函数内部，修改 a, b, c 的值，也就是修改了外部 x ，y，z 的值。

4. 性能问题和常数引用

对于参数是通过值(by value)传递的函数，参数的值会被 copy 一份传入函数。对于基本类型比如 int，这样的开销是很小的。但对于大的复合类型，不如 string，这样的开销还是很大的。比如：

string concatenate (string a, string b)
{
  return a+b;
}

如果有两个很长的字符作为 concatenate 的参数，那么意味着，仅仅是在调用这个函数的时候，就会有大量的数据被拷贝。

但是，如果我们使用引用，这样的问题就可以被避免：

string concatenate (string& a, string& b)
{
  return a+b;
}

  - 注意 这种通引用 by reference 传递参数的方式只是在C++中适用。在C 语言中，我们必须用指针(pointers)来做相同的操作。

综上可知，使用引用传递参数有两个优势：

1. 不需要再 copy 值，提升性能。

2. 修改了参数的值也就修改了外部变量的值。

如果只想利用第1点，避免第2点，怎么办？方法是把参数声明为常量(constant):

string concatenate (const string& a, const string& b)
{
  return a+b;
}

这样，使用常量引用，既达到了像值传递那样使用参数，又可以像引用传递那样提升性能。