指標：指向一塊記憶體地址的標識。

引用：給已經定義的變數起的別名。

格式：

型別 &引用變數名 = 已定義的變數名（引用變數名和已定義的變數名可以看成是同一個實體，一個改變，另一個也隨之改變）

引用的特點：

（1）引用必須初始化

int a = 10;
int &ra = a;

（2）一個變數可以有多個引用

int a = 10;
int &ra = a;
int &qa = a;

（3）當一個引用確定後，不可以引用其他變數

int a = 10;
int &ra = a;
int b = 20;

在這裡，ra是不可以再作為變數b的別名的。引用確定後，第一次是哪個實體，後邊是不可修改的。

（4）你可能還會碰到類似這樣的：

int a = 10;
double &qa = a;       //error

如果這裡不使用引用的話，可以直接隱式的強制型別轉換，編譯器不會報錯。而這裡使用了引用之後，會產生一個臨時變數，這個臨時變數是常量，其具有常屬性（一個常屬性的變數賦給另一個變數時，為了保證不修改原變數，應在另一變數前加關鍵字const），所以應該這樣定義：

int a = 10;
const double qa = a;     //OK

（5）陣列的引用

int a[10];
int (&b)[10]= a;

（6）引用--函式

#include<iostream>
using namespace std;
int& Fun(int a)
{
	return a;
}
int main()
{
	int &b = Fun(10);
	printf("%d\n",b);      //b壓棧，輸出10，銷燬
	printf("%d\n",20);
	printf("%d\n",b);
	system("pause");
	return 0;
}
 

 明明把b和Fun()函式是同一實體，為什麼輸出第二個b時會出現隨機值呢？

對於引用來說，b和Fun()函式是同一實體，所以呢，在Fun()函式裡的a，是一個臨時變數，出了作用域後就會自動銷燬，所以在第一次的printf函式中，先將b壓棧，然後可以輸出10，當printf函式完成後，將銷燬掉那塊記憶體；因此下次再訪問b時，就會出現隨機值。

那麼在這裡怎麼避免這種情況呢？

**解決方法：返回比int&的生命週期長的變數

#include<iostream>
using namespace std;
int& Fun(int& a)
{
	return a;
}

int main()
{
	int a = 10;
	int &b = Fun(a);
	printf("%d\n",b);
	printf("%d\n",20);
	printf("%d\n",b);
	system("pause");
	return 0;
}
 

說完引用的幾大特性後，再看看區別吧~~

值傳遞和引用傳遞的區別：引用傳遞不需要建立臨時變數，而值傳遞則需要。

指標和引用的區別和聯絡：

（通過彙編看）底層的處理方式是一樣的。

區別：

（1）指標不用初始化，而引用則需要。

int a = 10;
int *p;
int &ra = a;

（2）指標的指向不唯一，引用只能指向一個。（引用：一夫一妻制）

int a = 10;
int b = 20;
int *p = &a;
int &ra = a;
p = &b;

（3）對於自加減的意義。

指標自加減：偏移指標型別個位；

引用自加減：給引用的實體加1或減1；

#include<iostream>
using namespace std;
int main()
{
	int a[10] = {1,2,3};
	int b = 20;
	int *p = a;
	int &ra = b;
	p++;
	ra++;
	cout<<*p<<endl;
	cout<<ra<<endl;
	system("pause");
	return 0;
}

（4）關於sizeof()

#include<iostream>
using namespace std;
int main()
{
	char b = 20;
	char *p = &b;
	char &ra = b;
	cout<<sizeof(p)<<endl;
	cout<<sizeof(ra)<<endl;
	system("pause");
	return 0;
}

指標表示的是指標型別的大小；

引用表示的是已定義的變數的型別。

（5）有多級指標，無多級引用。

多級指標：int **p;   二級指標

int &&p = a;這裡指的是右值的引用，而並非二級引用哦。這裡沒有多級引用。

（6）引用比指標更安全。

指標每次使用時，都需判空。引用則不需要。

**測試值傳遞和引用傳遞的效率：

（1）值傳遞

<span style="font-size:18px;">#include<iostream>
using namespace std;
#include<Windows.h>
struct BigData
{
	int array[10000];
};

void setBigData(BigData data)
{
	data.array[0] = 0;
	data.array[1] = 1;
	data.array[2] = 2;
}
int main()
{
	BigData data;
	int begin = GetTickCount();
	for(long long int i = 0; i < 1000000; i++)
	{
		setBigData(data);
	}
	int end = GetTickCount();
	cout<<"cost time:"<<end-begin<<endl;
	system("pause");
	return 0;
}</span>

（2）引用傳遞

#include<iostream>
using namespace std;
#include<Windows.h>
struct BigData
{
	int array[10000];
};

void setBigData(BigData& data)
{
	data.array[0] = 0;
	data.array[1] = 1;
	data.array[2] = 2;
}
int main()
{
	BigData data;
	int begin = GetTickCount();
	for(long long int i = 0; i < 1000000; i++)
	{
		setBigData(data);
	}
	int end = GetTickCount();
	cout<<"cost time:"<<end-begin<<endl;
	system("pause");
	return 0;
}

所以一般情況下會使用引用傳參，引用的效率明顯比傳值的效率要高。

如果不希望傳的參被修改的話，還可用常引用的方式，即const BigData& data。