首先，強調一點，和函數傳參一樣，函數返回時也會做一個拷貝。

從某種角度上看，和傳參一樣，也分為三種：

• 返回值：返回任意類型的數據類型，會將返回數據做一個拷貝（副本）賦值給變量；由于需要拷貝，所以對于復雜對象這種方式效率比較低（調用對象的拷貝構造函數、析構函數）；例如：int test(){}或者 Point test(){}
• 返回指針：返回一個指針，也叫指針類型的函數，在返回時只拷貝地址，對于對象不會調用拷貝構造函數和析構函數；例如：int *test(){} 或者 Point *test(){}
• 返回引用：返回一個引用，也叫引用類型的函數，在返回時只拷貝地址，對于對象不會調用拷貝構造函數和析構函數；例如：int &test(){}或者 Point &test(){}

一般來說，在函數內對于存在棧上的局部變量的作用域只在函數內部，在函數返回后，局部變量的內存會自動釋放。因此，如果函數返回的是局部變量的值，不涉及地址，程序不會出錯；但是如果返回的是局部變量的地址（指針）的話，就會造成野指針，程序運行會出錯。因為函數只是把指針復制后返回了，但是指針指向的內容已經被釋放，這樣指針指向的內容就是不可預料，調用就會出錯。

1、返回值

int test1() {
? int a = 1;
? return a;
}

返回值是最簡單有效的方式，他的操作主要在棧上，根據函數棧的特性局部變量a會在函數結束時被刪除，為了返回a的值，需要產生a的復制。

如果a原子類型這當然也無所謂，但是如果a是大的對像，那么對a的復制將會產生比較嚴重的資源和性能消耗。

注：函數返回值本身因為沒有名稱或引用，所以是右值，是不能直接操作的。

2、指針類型的函數——返回指針

若函數的返回值是指針，該函數就是指針類型的函數。（即函數return一個指針，該指針可以是任何類型的）

1）指針類型的函數定義：

<類型> *函數名(參數)

int *test1() {
? int *b = new int();
? *b = 3;
? return b;
}

根據函數棧的特性也會產生復制，但是這個復制只是4（或8）字節，對于返回大型對像或數組來說可減少資源。但是返回指針資源的清理工作交給了調用者，這某種意義上違反了誰申請誰銷毀的原則。

注：函數返回指針也是右值，同樣無法操作。

2）說明：

• 不要將非靜態局部地址用作函數返回值：因為局部地址在離開函數后就失效了。
• 可以在函數中用動態內存分配（new）的地址返回，但需要注意內存分配和釋放不在同一級別，不要忘記釋放，否則內存泄露；
• 可以在主調函數中定義數組，函數中對該數組進行操作，然后返回其中一個元素的地址；

3、返回引用

1）引用類型函數的定義：

<類型> &函數名(參數)

int &test3() {
? int *c = new int();
? *c = 5;
? return *c;
}

引用是C++中新添加的概念，所以返回引用也是C++中相對于C來說所沒有的。引用是值的別名，和指針一樣不存在對大對像本身的復制，只是引用別名的復制。引用是左值，返回引用可以直接操作，也就可以進行連續賦值，最經典的示例是拷貝構造函數和運算符重載一般返回引用。

test3() +=3;

2）說明：

• 和返回指針一樣，不要將非靜態局部變量的引用用作函數返回值：因為局部地址在離開函數后就失效了。
• 和返回指針一樣，用動態內存分配（new）的局部指針可以作為引用返回，但是和返回指針一樣需要調用者自己去清理內存，否則內存泄露；

總結：

在C時代函數只能返回值、指針兩種，這兩種返回的都是右值；前者對于返回對象時要進行拷貝，效率比較低（會執行對象的拷貝構造函數、析構函數），后者不會發生；

C++時代除了上面兩種外，多了返回引用，這種返回時一種左值，特性和返回指針一樣；

4、綜合示例

1）返回棧內局部變量：

#include <iostream>
using namespace std;
int fun1() {
? ? int i = 1;
? ? cout<<"fun1 i address"<<&i<<endl;
? ? return i;//ok,返回值是i值得拷貝
}
int *fun2() {//指針類型的函數
? ? int i = 2;
? ? int *ip = &i;
? ? cout<<"fun2 i address"<<ip<<endl;
? ? return ip; // Wrong!返回值是ip指針的拷貝,但該地址在函數結束后會釋放變得無效
}
int main() {
? ? int r1 = fun1();
? ? cout<<"main fun1 return i address"<<&r1<<endl;
? ? cout << r1 << endl; // 1
?
? ? int *r2 = fun2();
? ? cout<<"main fun2 return i address"<<r2<<endl;
? ? //這里有可能出錯:具體看對應的內存是否被覆蓋,但總之該內存已無效
? ? cout << *r2 << endl;//0
?
? ? return 0;
}

輸出：

fun1 i address0x7ffc49e9b69c
main fun1 return i address0x7ffc49e9b6b4
1
fun2 i address0x7ffc49e9b694
main fun2 return i address0x7ffc49e9b694
0

我們在看一個對象的例子：

#include <iostream>
?
using namespace std;
?
class Point {
? public:
? ? Point(int a,int b):x(a),y(b){}
? ? int getX();
? ? void setX(int x);
? private:
? ? int x,y;
};
?
int Point::getX(){
? return x;
}
void Point::setX(int a) {
? x = a;
}
Point func(int x) {
? Point p(x,100);
? cout<<"func1 p address:"<<&p<<endl;
? return p;//ok,發生一次Point拷貝
}
Point *func2(int x) {//指針函數
? Point p(x,200);
? cout<<"func2 p address:"<<&p<<endl;
? return &p;//wrong,返回值是p地址的拷貝,但該地址在函數結束后會被釋放變得無效
}
main() {
? Point p = func(1);
? cout<<"main return p address:"<<&p<<endl;
? cout<<"main return p x:"<<p.getX()<<endl;
?
? Point *p2 = func2(2);
? cout<<"main return p address:"<<p2<<endl;
? cout<<"main return p x:"<<p2->getX()<<endl;
}

編譯的時候會有一個警告：

test88.cpp: In function ‘Point* func2(int)’:
test88.cpp:26:9: warning: address of local variable ‘p’ returned [-Wreturn-local-addr]
? ?Point p(x,200);
? ? ? ? ?^

輸出：

func1 p address:0x7fff0f005270
main return p address:0x7fff0f005290
main return p x:1
func2 p address:0x7fff0f005270
main return p address:0x7fff0f005270
main return p x:6299776

結論：對于棧內局部變量，采用一般的返回值，實際上是對返回值的一次值拷貝，在內存里會有兩個示例；對于指針類型函數的返回值，實際上是對地址的一次拷貝，內存只有一個示例，但該地址是一個非法的地址，在使用時會出現問題。

2）返回字符串：

通過 char* s = “Hello”; 的方式得到的是一個字符串常量 Hello，存放在只讀數據段（.rodata section），把該字符串常量的只讀數據段的首地址賦值給了指針 s，所以函數返回時，該字符串常量所在的內存不會被回收，所以能正確地通過指針訪問。

#include <iostream>
using namespace std;
?
char *fun1() {
? char *s="hello";
? return s;//ok
}
?
int main() {
? char *c1 = fun1();
? cout<<c1<<endl;
? //常量，無法在修改?
??
? return 0;
}

3）靜態變量：

可以把局部變量聲明為static靜態變量。這樣變量存儲在靜態存儲區，程序運行過程中一直存在。

int *fun3(){
? static int i = 5;
? cout<<"fun3 i address:"<<&i<<endl;
? return &i;
}
int main() {
?
? int *r1 = fun3();
? cout<<"main return i address:"<<r1<<endl;
? cout<<*r1<<endl;
}

輸出：

fun3 i address:0x602078
main return i address:0x602078
5

4）數組：

數組是不能作為函數的返回值的。因為編譯器會把數組名認為是局部變量（數組）的地址。返回一個數組，實際上是返回指向這個數組首地址的指針。函數結束后，數組作為局部變量被釋放，這個指針則變成了野指針。但是聲明數組是靜態的，然后返回是可以的。

int *fun4() {
? static int a[2]={4,5};
? cout<<"fun4 a[] address:"<<&a<<endl;
? return a;
}
int main() {
? int *r2 = fun4();
? cout<<"main return a[] address:"<<r2<<endl;
? cout<<*r2<<endl;
}

輸出：

fun4 a[] address:0x60207c
main return a[] address:0x60207c
4

5）堆內變量：

函數返回指向存儲在堆上的變量的指針是可以的。但是，程序員要自己負責在函數外釋放（free/delete）分配。

int *fun5() {
? int *j = new int;
? *j = 99;
? cout<<"fun5 j address:"<<j<<endl;
? return j;
}
int main() {
?
? int *r3 = fun5();
? cout<<"main return j address:"<<r3<<endl;
? cout<<*r3<<endl;
? *r3 = 100;
? cout<<*r3<<endl;
? delete r3;
}

輸出：

fun5 j address:0x208b010
main return j address:0x208b010
99
100

綜上，C++的函數返回和函數傳參有所不同，返回值和傳參一樣也有三種類型：

• 使用一般（傳統）的函數返回，對于復雜對象會涉及到拷貝效率問題；
• 使用指針類型的函數會有很多限制和弊端（容易內存泄露）；
• 引用類型的函數又是一個雞肋；

所以一般C++函數都是用傳址的方式進行雙向數據綁定，而返回值僅僅是一個成功或失敗的標志。