首先，強調(diào)一點，和函數(shù)傳參一樣，函數(shù)返回時也會做一個拷貝。

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

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

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

1、返回值

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

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

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

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

2、指針類型的函數(shù)——返回指針

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

1）指針類型的函數(shù)定義：

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

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

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

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

2）說明：

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

3、返回引用

1）引用類型函數(shù)的定義：

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

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

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

test3() +=3;

2）說明：

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

總結(jié)：

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

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

4、綜合示例

1）返回棧內(nèi)局部變量：

#include <iostream>
using namespace std;
int fun1() {
? ? int i = 1;
? ? cout<<"fun1 i address"<<&i<<endl;
? ? return i;//ok,返回值是i值得拷貝
}
int *fun2() {//指針類型的函數(shù)
? ? int i = 2;
? ? int *ip = &i;
? ? cout<<"fun2 i address"<<ip<<endl;
? ? return ip; // Wrong!返回值是ip指針的拷貝,但該地址在函數(shù)結(jié)束后會釋放變得無效
}
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;
? ? //這里有可能出錯:具體看對應(yīng)的內(nèi)存是否被覆蓋,但總之該內(nèi)存已無效
? ? 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,發(fā)生一次Point拷貝
}
Point *func2(int x) {//指針函數(shù)
? Point p(x,200);
? cout<<"func2 p address:"<<&p<<endl;
? return &p;//wrong,返回值是p地址的拷貝,但該地址在函數(shù)結(jié)束后會被釋放變得無效
}
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

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

2）返回字符串：

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

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

3）靜態(tài)變量：

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

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）數(shù)組：

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

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）堆內(nèi)變量：

函數(shù)返回指向存儲在堆上的變量的指針是可以的。但是，程序員要自己負責在函數(shù)外釋放（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++的函數(shù)返回和函數(shù)傳參有所不同，返回值和傳參一樣也有三種類型：

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

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

以上為個人經(jīng)驗，希望能給大家一個參考，也希望大家多多支持腳本之家。

最新評論