一，变量的引用
1.引用是一种新的变量类型，它的作用就是为变量起一个别名
例如：

int b;
int &a=b;

注：&表示引用声明符，不表示地址

2.声明一个引用类型变量时，必须在定义时进行初始化,及声明它代表哪一个变量
例如：

#include<iostream>
using namespace std;
int main()
{
  int b;
  b=10;//赋初值
  int &a=b;//引用
  cout<<b<<endl;
  cout<<"-------"<<endl;
  cout<<a<<endl; 
  return 0; 
}

二，引用作为函数的形参以及返回值
1.引用作为函数的形参

#include <iostream>
using namespace std;
int main()
{
      void swap(int & ,int& );
      int i =7,j = 5;
      swap(i,j);
     cout<<"i="<<i<<endl<<"j="<<j<<endl;
      getchar();
      return 0;
}
 
void swap(int &a,int &b)
{
    int temp;
    temp = a;
    a =b;
    b= temp;

结果：
i=5
j=7
注：形参是声明的引用，注意这个引用没有初始化，在调用函数时实现了初始化，做到了真正意义变量传递

引用和指针做形参是很常见的问题，但是它们在做参数的时候是有区别的
先说一下指针吧，指针他是一个变量，有具体的值，他的值是一个地址。而引用是对一个变量的引用，是变量的别名，并且在引用的时候必须要初始化。
2.引用作为函数的返回值

用引用返回一个函数值的最大好处是，在内存中不产生被返回值的副本

#include<iostream>
using namespace std;
float temp;
float fn1(float r){
    temp=r*r*3.14;
    return temp;
} 
float &fn2(float r){ //&说明返回的是temp的引用，换句话说就是返回temp本身
    temp=r*r*3.14;
    return temp;
}

注：当返回类成员引用时，最好是const引用，可以避免破坏类的成员

设计一个函数，调用该函数时，实现整型变量x与y值得互换。如下程序：

#include<iostream>
using namespace std;
void swap(int a,int b){int s;s=a;a=b;b=s}
int main(){
     int x=4,y=5;
     swap(x,y);
     cout<<x<<' '<<y<<endl;
     return 0;
}

运行结果：

4 5
请按任意键继续 . . .

当我们调用调用函数时，为没有实现实参x与y间值得互换，原因在于当我们调用函数时，首先进行实参与形参间的值得传递，即令a=x,b=y，之后实参的任务完成，被调用函数完成形参a与b间值得互换。
要实现实参x与y间值得互换，可以利用指针与引用：

一、指针

利用指针，将形参作为实参的地址，在进行地址中的内容进行互换，就可以实现x与y间值得互换，程序设计如下：

#include<iostream>
using namespace std;
void swap(int *a,int *b){int s;s=*a;*a=*b;*b=s}
int main(){
     int x=4,y=5;
     swap(&x,&y);
     cout<<x<<' '<<y<<endl;
     return 0;
}

运行结果：

5 4
请按任意键继续 . . .

思考：

下面程序的输出结果是什么？和上面利用指针设计的程序输出结果相同吗？为什么会这样？

#include<iostream>
using namespace std;
void swap(int *a,int *b){int *s;s=a;a=b;b=s}
int main(){
     int x=4,y=5;
     swap(&x,&y);
     cout<<x<<' '<<y<<endl;
     return 0;
}

二、引用

引用可以理解为为一个数据对象起了一个别名，当我们对一个数据对象的引用作操作时，也就是对该数据对象的操作。因此，将形参设计成实参的引用，就可以实现我们的目的。

#include<iostream>
using namespace std;
void swap(int& a,int& b){int s;s=a;a=b;b=s}
int main(){
     int x=4,y=5;
     swap(x,y);
     cout<<x<<' '<<y<<endl;
     return 0;
}

运行结果：

5 4
请按任意键继续 . . .

swap函数对x与y的引用做了换值操作，也就是对x与y做了换值的操作。

通过以上程序我们可以看出，引用作为参数最大的好处是既可以像指针那样工作，其使用方式又一般变量相同。引用比指针更具有可读性。

更多精彩内容请关注微信订阅号“编程语言初学者”，我们会将不同网站发布的博客、推文统一发布于编程语言初学者订阅号。

在C++中引用就相当于是给变量起了一个别名，有点类似于指针，但是与指针又不同。

引用的初始化

int i;
i = 10;
//变量i的引用
//引用必须在创建的时候就要初始化,而指针可以在任意的时候初始化
//引用就相当于是给变量起了一个别名
int& i_r=i;   //i_r指向了变量i的内存地址

//我们可以查看地址
TRACE("the addr of i:%d\n", &i);
TRACE("the addr of i_r:%d\n", &i_r);  

输出如下所示：

我们会发现引用和变量名指向的是同一个地址。

引用赋值

i = 30;
int i2 = 0;
//i_r = &i2;     //错误：一旦引用被初始化为一个对象，就不能被指向到另一个对象。指针可以在任何时候指向另外一个对象。
i_r = 25;		 //i的值也会发生变化

引用作为函数的形参

我定义一个交换函数：

void swap(int& x, int& y)
{
	int tmp;
	tmp = x;
	x = y;
	y = tmp;
}

在main函数中调用：

int x1 = 100;
int y1 = 200;
TRACE("Before swap x1=%d y1=%d\n",x1,y1);

//因为形参是引用，所以形参会指向实参的地址单元，这样在函数内部对形参的修改，就会改变实参的值

swap(x1, y1);
TRACE("After swap x1=%d y1=%d\n", x1, y1);

输出如下：

函数返回值为引用

在.h头文件定义如下：

int s_i;
double d[20];
double& setdouble(int i);
int& setint();

实现如下：

double& CmfcusereferenceDlg::setdouble(int i)
{
	return d[i];
}

int& CmfcusereferenceDlg::setint()
{
	return s_i;
}

在main函数中调用如下：

//练习引用作为返回值
setdouble(1) = 30.0;   

setint() = 5.0;

我们可以看到成员变量值的变化。

指针和引用的区别：
1.引用必须在创建的时候就要初始化，而指针可以在任意的时候初始化
2.引用一旦初始化指向了一个对象，就不能再指向另外一个对象。而指针可以在任何时候指向另外一个对象