引用的概念

引用 不是新定義一個變量，而 是給已存在變量取了一個別名 ，編譯器不會為引用變量開辟內存空間，它和它引用的變量共用同一塊內存空間。

引用的表示方法

類型 & 引用變量名 ( 對象名 ) = 引用實體；

如果熟悉C語言的同學可能會發(fā)現(xiàn)引用符號(&)看上去就像取地址運算符(&)或者按位AND運算符(&)，其實這是一個運算符重載的例子。通過重載，同一個運算符將會有不同的含義。編譯器會通過上下文來確定運算符的含義。除了這里所提到的，其實在C++中還有一些運算符重載的情況。例如：* 即表示乘法，又表示對指針的解引用操作；<<即表示插入運算符，又表示按位左移運算符等。

代碼實例：

int main()
{
	//引用：取別名
	int a = 10;
	int& b = a;//定義引用類型
	int& c = b;
	return 0;
}

本段代碼我們可以得知，a變量取了b，c兩個別名。

我們也可以通過調試觀察他們的內存：

通過調取內存我們可以發(fā)現(xiàn)，a,b,c所指向的是同一塊內存空間。

注意： 引用類型 必須和引用 實體 是 同種類型 的

引用特性

引用有三個特性，分別是：

1. 引用在 定義時必須初始化

2. 一個變量可以有多個引用

3. 引用一旦引用一個實體，再不能引用其他實體

1.引用在定義的時候必須初始化

由于引用是對已經存在的變量進行取別名，因此使用引用時必須指定變量(初始化)。

int& d;//錯誤，未初始化

2.一個變量可以有多個引用

在C++語法中，一個變量有多個引用，就類似于一個人可以有多個外號。在1.1的代碼實例中變量a就有2個引用，分別是b和c。

3.引用一旦引用一個實體，再不能引用其他實體

這個也比較好理解，因為引用一旦引用了一個已經存在的實體，就是這個實體的別名，當然不能再成為其他實體的別名。

常引用與引用權限

我們來觀察下面這段代碼，他能編譯成功嗎？

int main()
{
   //1.
	const int x = 20;
	int& y = x;      
	return 0;
}

當我們編譯這段代碼發(fā)現(xiàn)編譯器報出錯誤警告：無法從“const int”轉換為“int &”

這是因為我們在引用的時候要遵守引用的原則：

引用原則:對原變量的引用，權限不能放大。

1.3這段代碼中x變量是const修飾是一個常變量，只有可讀權限。而我們引用的類型是int，不僅有可讀權限，還有可修改權限。這就造成了對原變量的權限放大。根據我們引用原則知道，對原變量的引用，權限是不能放大的，這就是為什么這段代碼會報錯的原因。

那我們再來看這一段代碼，它能編譯成功嗎？

int main()
{
	//2.
	const int x = 20;
	const int& y = x;//不變
    //3.
	int c = 30;
	const int& d = c;//縮小
	return 0;
}

這段代碼我們發(fā)現(xiàn)編譯成功了，我們也可以輕松地分析出這里的引用是遵守引用規(guī)則的，我們發(fā)現(xiàn)，權限不變或者權限縮小都是符合規(guī)則的，唯一需要注意的是：權限不能放大。

引用的使用場景

做參數

void Swap(int& x, int& y)
{
	int tmp = x;
	x = y;
	y = tmp;
}
int main()
{
	int a = 0, b = 1;
	Swap(a, b);
	return 0;
}

引用可以作函數的形參，x是a的別名，y是b的別名。這里使用引用更加方便，也更好理解。

那既然以值作為函數參數和以引用作為函數參數都能解決這個問題，那為什么還要使用引用來做參數呢？這是因為引用的效率更高，我們可以通過下面這段測試代碼更加直觀看出效率的差別：

#include <time.h>
struct A { int a[10000]; };
void TestFunc1(A a) {}
void TestFunc2(A& a) {}
void TestRefAndValue()
{
	A a;
	// 以值作為函數參數
	size_t begin1 = clock();
	for (size_t i = 0; i < 10000; ++i)
		TestFunc1(a);
	size_t end1 = clock();
	// 以引用作為函數參數
	size_t begin2 = clock();
	for (size_t i = 0; i < 10000; ++i)
		TestFunc2(a);
	size_t end2 = clock();
	// 分別計算兩個函數運行結束后的時間
	cout << "TestFunc1(A)-time:" << end1 - begin1 << endl;
	cout << "TestFunc2(A&)-time:" << end2 - begin2 << endl;
}
int main()
{
	TestRefAndValue();
	return 0;
}

我們發(fā)現(xiàn)使用引用作為函數參數效率大大提高。以值作為參數或者返回值類型，在傳參和返回期間，函數不會直接傳遞實參或者將變量本身直接返回，而是傳遞實參或者返回變量的一份臨時的拷貝，因此用值作為參數或者返回值類型，效率是非常低下的，尤其是當參數或者返回值類型非常大時，效率就更低。

引用做參數的意義：

1.輸出型參數。

2.減少拷貝，提高效率。

做返回值

首先我們來觀察這段代碼的返回值是什么?

int Count()
{
	static int n = 0;
	n++;
	return n;
}
int main()
{
	cout << Count() << endl;
	cout << Count() << endl;
	cout << Count() << endl;
	return 0;
}

這里的結果是：

1 2 3

因為n是局部靜態(tài)的成員變量，只會初始化一次，雖然作用域在Count函數內部，但是生命周期是全局，我們可以通過調試觀看他是否再執(zhí)行函數的第一句？

傳值的底層過程

傳值返回這個過程當中會產生一個臨時變量，跟傳參一樣，如果小會用寄存器替代。傳值返回的類型其實是臨時變量的類型，將n拷貝給臨時變量，再將臨時變量拷貝給ret。那么為什么要設計臨時變量呢？直接把n給ret不好嗎？

這是因為在當臨時變量出了函數作用域之后會銷毀，函數棧楨也會銷毀，那么此時n是不能作為返回值再賦值給ret的。那么編譯器就在此生成了一個臨時變量，把n拷給臨時變量，再把臨時變量給ret。此時，函數棧楨銷毀是不會影響臨時變量的。

那我們怎么可以證明這個過程產生了臨時變量，我們可以給ret前加個引用。

此時我們發(fā)現(xiàn)，編譯器是過不了的，這是因為此時ret是引用的臨時變量，而臨時變量具有常性，這里屬于權限的放大，因此我們只需要加上const即可。我們也通過這個例子證明了臨時變量的存在。

那現(xiàn)在我們給Count函數加個引用是什么意思？我們來看這段代碼。

int& Count()
{
	int n = 0;
	n++; 
	return n;
}
//中間產生了一個臨時變量
int main()
{
	int ret = Count(); 
	return 0;
}

這里可以這么認為，中間也會產生一個臨時變量，這個臨時變量的類型為int&，此時這個臨時變量是n的別名，再把臨時變量賦給ret。返回的是一個n的別名，就相當于是吧n返回給了ret。

此時我們再觀察這段代碼我們發(fā)現(xiàn)編譯器可以通過了，這里ret相當于是n的別名。

我們可以打印n和ret的地址看看：

這里ret和n的地址相同，也能證明ret是n的別名。因此，引用作為返回值其實返回的就是n的別名。

引用導致野指針

這段代碼合法嗎？

其實這段代碼是不合法的，因為出了函數的作用域，Count函數已經銷毀了，我們再對此空間進行訪問，就會造成非法訪問，這里就是引用搞出來的野指針。

我們來驗證一下：

//傳引用返回的是n的別名
int& Count()
{
	int n = 0;
	n++; 
	//cout << "n:"<< & n << endl;
	return n;
}
//中間產生了一個臨時變量
int main()
{
	int& ret = Count(); //ret是別名的別名  也就是n的別名
	cout << ret << endl;
	cout << "ret"<< & ret << endl;
	cout << ret << endl;
	return 0;
}

通過打印我們能夠發(fā)現(xiàn)：第二個ret打印的是隨機值。

因此此處需要注意 ：

如果函數返回時，出了函數作用域，如果返回對象還未還給系統(tǒng)，則可以使用引用返回，如果已 經還給系統(tǒng)了，則必須使用傳值返回。

我們來做一個實例鞏固一下：

下面這段代碼的結果是什么？為什么？

int& Add(int a, int b) 
{
	int c = a + b;
	return c;
}
int main()
{
	int& ret = Add(1, 2);
	Add(3, 4);
	cout << "Add(1, 2) is :" << ret << endl;
	return 0;
}

結果：7，這里是因為在第一次調用Add時，ret為3，Add函數的棧楨銷毀，在第二次調用時，Add函數的棧楨是相同的，c的位置為覆蓋為7，再次訪問ret此時就為7，因此這里使用是不安全的。以下打印就可以更加清晰了解這個過程。

值和引用作為返回值類型的性能比較

#include <time.h>
struct A { int a[10000]; };
A a;
// 值返回
A TestFunc1() { return a; }
// 引用返回
A& TestFunc2() { return a; }
void TestReturnByRefOrValue()
{
	// 以值作為函數的返回值類型
	size_t begin1 = clock();
	for (size_t i = 0; i < 100000; ++i)
		TestFunc1();
	size_t end1 = clock();
	// 以引用作為函數的返回值類型
	size_t begin2 = clock();
	for (size_t i = 0; i < 100000; ++i)
		TestFunc2();
	size_t end2 = clock();
	// 計算兩個函數運算完成之后的時間
	cout << "TestFunc1 time:" << end1 - begin1 << endl;
	cout << "TestFunc2 time:" << end2 - begin2 << endl;
}
int main()
{
	TestReturnByRefOrValue();
	return 0;
}

通過打印我們發(fā)現(xiàn)引用作為返回值類型大大提高了效率。

原因：以值作為參數或者返回值類型，在傳參和返回期間，函數不會直接傳遞實參或者將變量本身直接返回，而是傳遞實參或者返回變量的一份臨時的拷貝，因此用值作為參數或者返回值類型，效率是非常低下的，尤其是當參數或者返回值類型非常大時，效率就更低。

引用和指針的區(qū)別

引用在語法概念上引用就是一個別名，沒有獨立空間，和其引用實體共用同一塊空間。 在底層實現(xiàn)上實際是有空間的，因為引用是按照指針方式來實現(xiàn)的。

int main()
{
	int a = 10;
	int& ra = a;
	ra = 20;
	int* pa = &a;
	*pa = 20;
	return 0;
}

我們來看引用和指針的匯編代碼對比：

因此引用的底層實現(xiàn)上是按照指針的方式來實現(xiàn)的。

引用和指針的不同點:

1. 引用在定義時必須初始化，指針沒有要求

2. 引用在初始化時引用一個實體后，就不能再引用其他實體，而指針可以在任何時候指向任何一個同類型實體

3. 沒有NULL引用，但有NULL指針

4. 在sizeof中含義不同：引用結果為引用類型的大小，但指針始終是地址空間所占字節(jié)個數(32位平臺下占4個字節(jié))

5. 引用自加即引用的實體增加1，指針自加即指針向后偏移一個類型的大小

6. 有多級指針，但是沒有多級引用

7. 訪問實體方式不同，指針需要顯式解引用，引用編譯器自己處理

8. 引用比指針使用起來相對更安全

到此這篇關于c++超細致講解引用的文章就介紹到這了,更多相關 c++ 引用內容請搜索腳本之家以前的文章或繼續(xù)瀏覽下面的相關文章希望大家以后多多支持腳本之家！

最新評論