return語句終止當(dāng)前正在執(zhí)行的函數(shù)并將控制權(quán)返回到調(diào)用該函數(shù)的地方。

return語句有兩種形式

return;return expression;

無返回值函數(shù)

沒有返回值的return語句只能用在返回類型是void的函數(shù)中。

返回void的函數(shù)不要求必須有return語句，因為這類函數(shù)的最后一句后面會隱式地執(zhí)行return.

也就是說，下面這兩種寫法是等價的

void A()
{
return;
}void A()
{
}

一個返回類型是void的函數(shù)也能使用return語句的第二種形式，不過此時return語句的expression必須是另一個返回void的函數(shù)。強行令void函數(shù)返回其他類型的表達式將產(chǎn)生編譯錯誤。

void B(...)
{;
}
void A()
{return B();//B的返回類型是void，所以可以
}

int B(...)
{;
}
void A()
{return B();//B的返回類型不是void，所以不可以
}

有返回值函數(shù)

return 語句的第二種形式提供了函數(shù)的結(jié)果。

只要函數(shù)的返回類型不是 void，則該函數(shù)內(nèi)的每條return語句必須返回一個值。return語句返回值的類型必須與函數(shù)的返回類型相同，或者能隱式地轉(zhuǎn)換成函數(shù)的返回類型。

盡管C++無法確保結(jié)果的正確性，但是可以保證每個return語句的結(jié)果類型正確。也許無法顧及所有情況，但是編譯器仍然盡量確保具有返回值的函數(shù)只能通過一條有效的return語句退出。

例如：
?

int A()
{
return;//編譯器會報錯
}

第一段代碼的return語句是錯誤的，因為它沒有返回值，編譯器能檢測到這個錯誤。?

int A(int w)
{int i;
for(i=0;i<10;++i)
{
if(i==w)
return i;
}
}

?錯誤是函數(shù)在for 循環(huán)之后沒有提供return語句。在上面的程序中，如果i!=w，則函數(shù)在執(zhí)行完for循環(huán)后還將繼續(xù)其執(zhí)行過程，顯然應(yīng)該有一條return語句專門處理這種情況。編譯器也許能檢測到這個錯誤，也許不能：如果編譯器沒有發(fā)現(xiàn)這個錯誤，則運行時的行為將是未定義的。

在含有return語句的循環(huán)后面應(yīng)該也有一條return語句，如果沒有的話該程序就是錯誤的。很多編譯器都無法發(fā)現(xiàn)此類錯誤.

值是如何被返回的

返回值

返回一個值的方式和初始化一個變量或形參的方式完全一樣：返回的值用于初始化調(diào)
用點的一個臨時量，該臨時量就是函數(shù)調(diào)用的結(jié)果。

必須注意當(dāng)函數(shù)返回局部變量時的初始化規(guī)則。

例如我們書寫一個函數(shù)，給定計數(shù)值、單詞和結(jié)束符之后，判斷計數(shù)值是否大于1：如果是，返回單詞的復(fù)數(shù)形式；如果不是，返回單詞原形：

//如果ctr的值大于1，返回word的復(fù)數(shù)形式
string make_plural(size_t ctr, const string &word,?const string &ending)
{
return (ctr >1) ? word + ending : word;
}

該函數(shù)的返回類型是string，意味著返回值將被拷貝到調(diào)用點。因此，該函數(shù)將返回word
的副本或者一個未命名的臨時string對象，該對象的內(nèi)容是word和ending的和。

我們再看一個例子

int A()
{
int a=9;
return a;
}...
int b=A();

函數(shù)返回值是int類型，執(zhí)行return語句的同時把a的值拷貝到一個臨時的int變量上面，然后銷毀局部變量a，然后再將這個臨時變量賦給調(diào)用對象——變量b?

?返回引用

同其他引用類型一樣，如果函數(shù)返回引用，則該引用僅是它所引對象的一個別名。

舉個例子來說明，假定某函數(shù)挑出兩個string形參中較短的那個并返回其引用：

//挑出兩個string對象中較短的那個，返回其引用
const string &shorterstring(const string &sl, const string &s2)
{
return sl.size() <= s2.size() ? sl:s2;
}

其中形參和返回類型都是const string的引用，不管是調(diào)用函數(shù)還是返回結(jié)果都不會真正拷貝string對象。

不要返回局部對象的引用或指針

函數(shù)完成后，它所占用的存儲空間也隨之被釋放掉。因此，函數(shù)終止意味著局部變量的引用將指向不再有效的內(nèi)存區(qū)域：

//嚴(yán)重錯誤：這個函數(shù)試圖返回局部對象的引用
const int& A()
{
int a;
if(a==3)
return a;
else
return 4;}

?
上面的兩條return 語句都將返回未定義的值，也就是說，試圖使用返回值將引發(fā)未定義的行為，對于第一條return語句來說，顯然它返回局部對象的引用。對于第二條return語句來說，它返回了一個臨時的int值。

當(dāng)函數(shù)結(jié)束時，臨時對象占用的空間也就隨之釋放了，這兩條return語句都指向了不可再用的內(nèi)存空間。

有人可能好奇的去試了一下

int& AA()
{int a = 9;return a;
}int main()
{int g = AA();
cout<<g<<endl;
}

發(fā)現(xiàn)打印出了9啊。這是為什么呢？?

在這個代碼中，函數(shù)AA返回一個對局部變量a的引用。但是，這里有一個重要的問題：局部變量a在函數(shù)返回后會被銷毀，這意味著返回的引用指向了一個不再存在的變量。這通常會導(dǎo)致未定義行為，因為程序可能會嘗試訪問已經(jīng)被釋放的內(nèi)存。

在大多數(shù)編譯器和設(shè)置下，你可能會看到g的值是9，但這完全是偶然的。這是因為局部變量a在函數(shù)返回后可能仍然保留在內(nèi)存中的那個位置，并且它的值沒有被其他數(shù)據(jù)覆蓋。但是，這并不意味著這樣的代碼是安全的或可預(yù)測的。

現(xiàn)在，來詳細解釋一下函數(shù)返回的過程：

• 當(dāng)AA函數(shù)被調(diào)用時，它會在棧上分配空間來存儲局部變量a，并給它賦值為9。
• 然后，AA函數(shù)返回這個局部變量的引用。這本質(zhì)上是一個內(nèi)存地址。
• 在main函數(shù)中，你試圖將這個引用賦值給一個整數(shù)變量g。但是，因為引用本質(zhì)上是一個地址，所以這里發(fā)生了隱式解引用，即g被賦予了地址指向的值，即9。
• 最后，你打印出g的值，它看起來是9。

然而，由于前面提到的未定義行為，這個程序可能會在不同的編譯器、不同的優(yōu)化級別或不同的運行環(huán)境下表現(xiàn)出不同的行為。因此，這種代碼是不安全的，應(yīng)當(dāng)避免使用。

int* B()
{
int b;
int*c=&b;
return c;
}

同樣，返回局部對象的指針也是錯誤的一旦函數(shù)完成，局部對象被釋放，指針將指向一個不存在的對象。

同樣的道理，我們也來像上面一樣來看看下面這樣的程序

#include<iostream>
using namespace std;int* B()
{int b=5;int* c = &b;return c;
}int main()
{int *g = B();cout << *g << endl;
}

我們發(fā)現(xiàn)，打印出了5，這又是為啥呢？

在這段代碼中，函數(shù)B返回一個指向局部變量的指針。局部變量b在函數(shù)B的棧幀中分配，并在函數(shù)返回后不再存在。然而，由于你返回了指向它的指針，你仍然可以通過這個指針訪問它的內(nèi)存位置（盡管這是未定義行為，因為b已經(jīng)不再是一個有效的對象）。

這里是為什么這段代碼打印出5的原因：

1. 當(dāng)調(diào)用函數(shù)B時，它在棧上分配了局部變量b，并將其初始化為5。
2. 接下來，創(chuàng)建了一個指向b的指針c。
3. 函數(shù)B返回這個指針c，即返回了b的地址。
4. 在main函數(shù)中，你接收了這個返回的指針并將其存儲在g中。
5. 通過解引用g（即*g），你訪問了之前b所在的內(nèi)存位置，并打印出了存儲在那里的值，即5。

然而，這種行為是不安全的，因為它依賴于局部變量的棧內(nèi)存位置在函數(shù)返回后不會被改變。在實際編程中，這種做法是不推薦的，因為它可能導(dǎo)致不可預(yù)測的行為和程序崩潰，尤其是在更復(fù)雜的程序或者存在并發(fā)操作時。

正確的做法是避免返回指向局部變量的指針，或者確保在返回指針之前，所指向的數(shù)據(jù)已經(jīng)分配在了一個合適的持久存儲位置，比如動態(tài)分配的內(nèi)存（使用new或malloc等）。

關(guān)于函數(shù)返回過程：

• 函數(shù)B執(zhí)行完畢后，它的棧幀會被銷毀，包括其中的局部變量。然而，返回的指針c（或者說，它所指向的地址）并不會自動失效。
• 當(dāng)main函數(shù)接收這個指針并嘗試訪問它時，它實際上是在訪問一個已經(jīng)被銷毀的棧幀中的內(nèi)存位置。如果這個內(nèi)存位置在函數(shù)返回后沒有被其他函數(shù)調(diào)用覆蓋，那么你可能仍然能夠看到原來的值（就像在這個例子中一樣）。但是，這是不可預(yù)測的，并且是不安全的。

因此，盡管這段代碼在某些情況下可能看起來能夠正常工作，但它實際上包含了嚴(yán)重的錯誤和潛在的風(fēng)險。

?

返回類類型的函數(shù)和調(diào)用運算符

和其他運算符一樣，調(diào)用運算符也有優(yōu)先級和結(jié)合律。用運算符的優(yōu)先級與點運算符和箭頭運算符相同，并且也符合左結(jié)合律。

因此，如果函數(shù)返回指針、引用或類的對象，我們就能使用函數(shù)調(diào)用的結(jié)果訪問結(jié)果對象的成員。

例如，我們可以通過如下形式得到較短string對象的長度：

// 調(diào)用string 對象的size成員，該string對象是由shorterString函數(shù)返回的auto sz = shorterString(si, s2).size();

因為上面提到的運算符都滿足左結(jié)合律，所以 shorterString 的結(jié)果是點運算符的左側(cè)運算對象，點運算符可以得到該string對象的size成員，size又是第二個調(diào)用運算符的左側(cè)運算對象。

引用返回左值

• 函數(shù)的返回類型決定函數(shù)調(diào)用是否是左值。
• 調(diào)用一個返回引用的函數(shù)得到左值，其他返回類型得到右值。
• 可以像使用其他左值那樣來使用返回引用的函數(shù)的調(diào)用，特別是，我們能為返回類型是非常量引用的函數(shù)的結(jié)果賦值：

#include<iostream>
using namespace std;int& A(int &a)
{
return a;
}
int main()
{
int a=9;
cout<<a<<endl;
A(a)=99;//返回值當(dāng)左值用
cout<<a<<endl;
}

?

把函數(shù)調(diào)用放在賦值語句的左側(cè)可能看起來有點奇怪，但其實這沒什么特別的。

返回值是引用，因此調(diào)用是個左值，和其他左值一樣它也能出現(xiàn)在賦值運算符的左側(cè)。

如果返回類型是常量引用，我們不能給調(diào)用的結(jié)果賦值，這一點和我們熟悉的情況是一樣的：

列表初始化返回值

C++11新標(biāo)準(zhǔn)規(guī)定，函數(shù)可以返回花括號包圍的值的列表。類似于其他返回結(jié)果，此處的列表也用來對表示函數(shù)返回的臨時量進行初始化。如果列表為空，臨時量執(zhí)行值初始化；否則，返回的值由函數(shù)的返回類型決定。

舉個例子，回憶6.2.6節(jié)(第198頁)的error msg函數(shù)，該函數(shù)的輸入是一組可變數(shù)量的string實參，輸出由這些string對象組成的錯誤信息。在下面的函數(shù)中，我們返回一個vector對象，用它存放表示錯誤信息的string對象：

vector<string> process(){//...
// expected 和actual是string對象
if (expected.empty())
return {}; // 返回一個空vector對象
else if (expected == actual)
return {"functionX","okay"}; // 返回列表初始化的vector對象
else
return {"functionx", expected, actuall};}

第一條return語句返回一個空列表，此時，process函數(shù)返回的vector對象是空的。如果expected不為空，根據(jù)expected和actual是否相等，函數(shù)返回的vector對象分別用兩個或三個元素初始化。

• 如果函數(shù)返回的是內(nèi)置類型，則花括號包圍的列表最多包含一個值，而且該值所占空間不應(yīng)該大于目標(biāo)類型的空間。
• 如果函數(shù)返回的是類類型，由類本身定義初始值如何使用。

int C()
{return{ 1 };
}

主函數(shù)main的返回值

之前介紹過，如果函數(shù)的返回類型不是void，那么它必須返回一個值。

但是這條規(guī)則有個例外：我們允許main函數(shù)沒有return語句直接結(jié)束。

如果控制到達了main函數(shù)的結(jié)尾處而且沒有return語句，編譯器將隱式地插入一條返回0的return語句。

返回數(shù)組指針

因為數(shù)組不能被拷貝，所以函數(shù)不能返回數(shù)組。不過，函數(shù)可以返回數(shù)組的指針或引用。雖然從語法上來說，要想定義一個返回數(shù)組的指針或引用的函數(shù)比較煩瑣，但是有一些方法可以簡化這一任務(wù)，

其中最直接的方法是使用類型別名：

typedef int arrT[10]; //arrT是一個類型別名，它表示的類型是含有10個整數(shù)的數(shù)組
using? arxT = int[10]： //arrT的等價聲明
artT* func(int i); //func 返回一個指向含有10個整數(shù)的數(shù)組的指針

其中arrT是含有10個整數(shù)的數(shù)組的別名。因為我們無法返回數(shù)組，所以將返回類型定義成數(shù)組的指針。因此，func函數(shù)接受一個int實參，返回一個指向包含10個整數(shù)的數(shù)組的指針。
聲明一個返回數(shù)組指針的函數(shù)

要想在聲明func時不使用類型別名，我們必須記住，數(shù)組的維度應(yīng)跟隨在要定義的數(shù)組名之后：

int arr[10]； // arr是一個含有10個整數(shù)的數(shù)組
int *p1[10]； // p1是一個含有10個指針的數(shù)組
int (*p2)[10]= &arr; // p2是一個指針，它指向含有10個整數(shù)的數(shù)組

和這些聲明一樣，如果我們想定義一個返回數(shù)組指針的函數(shù)，則數(shù)組的維度必須跟在函數(shù)名字之后。然而，函數(shù)的形參列表也跟在函數(shù)名字后面且形參列表應(yīng)該先于數(shù)組的維度。

因此，返回數(shù)組指針的函數(shù)形式如下所示：

Type (*function (parameter_list))[dimension]

類似于其他數(shù)組的聲明，Type表示元素的類型，dimension 表示數(shù)組的大小。(*function(parameter_list))兩端的括號必須存在，就像我們定義p2時兩端必須有括號一樣。如果沒有這對括號，函數(shù)的返回類型將是指針的數(shù)組。

舉個具體點的例子，下面這個func函數(shù)的聲明沒有使用類型別名：

int (*func(int i))[10];

可以按照以下的順序來逐層理解該聲明的含義：

• func(int i)表示調(diào)用func函數(shù)時需要一個int類型的實參。
• (*func(int i))意味著我們可以對函數(shù)調(diào)用的結(jié)果執(zhí)行解引用操作。
• (*func(int i))[10]表示解引用func的調(diào)用將得到一個大小是10的數(shù)組。
• int (*func(int i))[10]表示數(shù)組中的元素是int類型。

使用尾置返回類型

在C++11新標(biāo)準(zhǔn)中還有一種可以簡化上述func聲明的方法，就是使用尾置返回類。

任何函數(shù)的定義都能使用尾置返回，但是這種形式對于返回類型較復(fù)雜的函數(shù)最有效，比如返回類型是數(shù)組的指針或者數(shù)組的引用。

尾置返回類型跟在形參列表后面并以一個>符號開頭。

為了表示函數(shù)真正的返回類型跟在形參列表之后，我們在本應(yīng)該出現(xiàn)返回類型的地方放置一auto:

// func 接受一個int 類型的實參，返回一個指針，該指針指向含有10個整數(shù)的數(shù)組
auto func(int i) -> int(*) [10]；

因為我們把函數(shù)的返回類型放在了形參列表之后，所以可以清楚地看到func函數(shù)返回的是一個指針，并且該指針指向了含有10個整數(shù)的數(shù)組。

我們再看一個例子

#include<iostream>
using namespace std;
auto BB() -> int
{int a = 9;return a;
}
auto BBB() -> int*
{int a = 9;return &a;
}
int main()
{cout << BB() << endl;cout << BBB() << endl;
}

使用 decltype

還有一種情況，如果我們知道函數(shù)返回的指針將指向哪個數(shù)組，就可以使用decltype關(guān)鍵字聲明返回類型。
例如，下面的函數(shù)返回一個指針，該指針根據(jù)參數(shù)i的不同指向兩個已知數(shù)組中的某一個：
?

int odd[] = {1,?3,5,7,9}；
int even[] = {0, 2, 4, 6, 8};
//返回一個指針，該指針指向含有5個整數(shù)的數(shù)組
decltype (odd) *arrPtr(int i){return (i %2) ? &odd: &even;// 返回一個指向數(shù)組的指針}

使用關(guān)鍵字 decltype 表示它的返回類型是個指針，并且該指針?biāo)傅膶ο笈codd的類型一致。

因為odd是數(shù)組，所以arrPtr返回一個指向含有5個整數(shù)的數(shù)組的指針。

有一個地方需要注意：decltype并不負責(zé)把數(shù)組類型轉(zhuǎn)換成對應(yīng)的指針，所以decltype的結(jié)果是個數(shù)組，要想表示arrPt返回指針還必須在函數(shù)聲明時加一個*符號

我們再看一個例子

#include<iostream>
using namespace std;int a = 9;
decltype(a) BB()
{int a = 9;return a;
}int main()
{
cout<<BB()<<endl;//結(jié)果是9
}

?