函數返回指針和返回數組名有什么區別


先看一個例子:

#include<iostream>

usingnamespace std;

 

char *fun(void)
{
char *p="hello the world";
char buffer[] = "hello the world";
return p; //這里為什么可以返回局部定義的指針?
// return buffer; //這里為什么不可以返回局部定義的數組名?

}

int main(void)
{
char *s;
s=fun();
printf("%s\n",s);
return 0;
}

這里返回的是指針的話程序可以正常輸出,但返回數組名則不可以。

因為字符串常量"hello the world"存放在文字常量區,可以理解為一個沒有名字的靜態變量(因為字符串常量很少需要修改,放在靜態內存區會提高效率)。

指針p指向了存放"hello the world"的文字常量區,所以可以正常返回。

而這里buffer是在函數棧里面開辟了內存空間,里面的內容是用文字常量區的字符串的拷貝,buffer指向棧內存,

fun函數調用結束后buffer指向的空間被操作系統收回,所以不能正常返回。

我們在fun函數中添加兩句:

cout<<(void *)p<<endl;
cout<<(void *)buffer<<endl;

來測試p和buffer所指向的地址空間是否相同:

輸出為:

0x402080
0x22ac1c

可以看出,這兩個指針所值空間是不同的,p指向文字常量區,buffer指向棧區。

下面引用一篇文章來作進一步說明:

#include
  using namespace std;
  
  char *fun(void)
  {
   char *p = "hello the world";//字符串常量"hello the world"存放在文字常量區,
   char buffer[] = "hello the world";//這里buffer是在函數棧里面開辟了內存空間,里面的內容是用文字常量區的字符串的拷貝
   return p; //p指向存放"hello the world"的文字常量區
  // return buffer; //buffer指向棧內存,fun函數調用結束后buffer指向的空間被操作系統收回
   
  }
  
  int main(void)
  {
   char *s;
   s=fun();
   printf("%s\n",s);
   return 0;
  }
  
  -------------------------------------------------------------------------------
  char *c="chenxi";
  書上說: "chenxi"這個字符串被當作常量而且被放置在此程序的內存靜態區。
  那一般的int i=1;
  1也是常量,為什么1就不被放置在此程序的內存靜態區了呢?
  請高手指點!
  
  所有的字符竄常量都被放在靜態內存區
  因為字符串常量很少需要修改,放在靜態內存區會提高效率
  
  例:
  
  char str1[] = "abc";
  char str2[] = "abc";
  
  const char str3[] = "abc";
  const char str4[] = "abc";
  
  const char *str5 = "abc";
  const char *str6 = "abc";
  
  char *str7 = "abc";
  char *str8 = "abc";
  
  
  cout << ( str1 == str2 ) << endl;
  cout << ( str3 == str4 ) << endl;
  cout << ( str5 == str6 ) << endl;
  cout << ( str7 == str8 ) << endl;
  
  結果是:0 0 1 1
  str1,str2,str3,str4是數組變量,它們有各自的內存空間;
  而str5,str6,str7,str8是指針,它們指向相同的常量區域。
  
   
  
   
  
  問題的引入:
  看看下面的程序的輸出:
  
  #include <stdio.h>
  char *returnStr()
  {
   char *p="hello world!";
   return p;
  }
  int main()
  {
   char *str=NULL;//一定要初始化,好習慣
   str=returnStr();
   printf("%s\n", str);
   
   return 0;
  }
  
  這個沒有任何問題,因為"hello world!"是一個字符串常量,存放在靜態數據區,
  把該字符串常量存放的靜態數據區的首地址賦值給了指針,
  所以returnStr函數退出時,該該字符串常量所在內存不會被回收,故能夠通過指針順利無誤的訪問。
  
  但是,下面的就有問題:
  
  #include <stdio.h>
  char *returnStr()
  {
   char p[]="hello world!";
   return p;
  }
  int main()
  {
   char *str=NULL;//一定要初始化,好習慣
   str=returnStr();
   printf("%s\n", str);
   
   return 0;
  }
  "hello world!"是一個字符串常量,存放在靜態數據區,沒錯,
  但是把一個字符串常量賦值給了一個局部變量(char []型數組),該局部變量存放在棧中,
  這樣就有兩塊內容一樣的內存,也就是說“char p[]="hello world!";”這條語句讓“hello world!”這個字符串在內存中有兩份拷貝,一份在動態分配的棧中,另一份在靜態存儲區。這是與前者最本質的區別,
  當returnStr函數退出時,棧要清空,局部變量的內存也被清空了,
  所以這時的函數返回的是一個已被釋放的內存地址,所以打印出來的是亂碼。
  
  如果函數的返回值非要是一個局部變量的地址,那么該局部變量一定要申明為static類型。如下:
  
  #include <stdio.h>
  char *returnStr()
  {
   static char p[]="hello world!";
   return p;
  }
  int main()
  {
   char *str=NULL;
   str=returnStr();
   printf("%s\n", str);
   
   return 0;
  }
  
  這個問題可以通過下面的一個例子來更好的說明:
  
  #include <stdio.h>
  //返回的是局部變量的地址,該地址位於動態數據區,棧里
  
  char *s1()
  {
   char* p1 = "qqq";//為了測試‘char p[]="Hello world!"’中的字符串在靜態存儲區是否也有一份拷貝
   char p[]="Hello world!";
   char* p2 = "w";//為了測試‘char p[]="Hello world!"’中的字符串在靜態存儲區是否也有一份拷貝
   printf("in s1 p=%p\n", p);
   printf("in s1 p1=%p\n", p1);
   printf("in s1: string's address: %p\n", &("Hello world!"));
   printf("in s1 p2=%p\n", p2);
   return p;
  }
  
  //返回的是字符串常量的地址,該地址位於靜態數據區
  
  char *s2()
  {
   char *q="Hello world!";
   printf("in s2 q=%p\n", q);
   printf("in s2: string's address: %p\n", &("Hello world!"));
   return q;
  }
  
  //返回的是靜態局部變量的地址,該地址位於靜態數據區
  
  char *s3()
  {
   static char r[]="Hello world!";
   printf("in s3 r=%p\n", r);
   printf("in s3: string's address: %p\n", &("Hello world!"));
   return r;
  }
  
  int main()
  {
   char *t1, *t2, *t3;
   t1=s1();
   t2=s2();
   t3=s3();
   
   printf("in main:");
   printf("p=%p, q=%p, r=%p\n", t1, t2, t3);
  
   printf("%s\n", t1);
   printf("%s\n", t2);
   printf("%s\n", t3);
   
   return 0;
  }
  運行輸出結果:
  
  in s1 p=0013FF0C
  in s1 p1=00431084
  in s1: string's address: 00431074
  in s1 p2=00431070
  in s2 q=00431074
  in s2: string's address: 00431074
  in s3 r=00434DC0
  in s3: string's address: 00431074
  in main:p=0013FF0C, q=00431074, r=00434DC0
  $
  Hello world!
  Hello world!
  
  這個結果正好應證了上面解釋,同時,還可是得出一個結論:
  字符串常量,之所以稱之為常量,因為它可一看作是一個沒有命名的字符串且為常量,存放在靜態數據區。
  這里說的靜態數據區,是相對於堆、棧等動態數據區而言的。
  靜態數據區存放的是全局變量和靜態變量,從這一點上來說,字符串常量又可以稱之為一個無名的靜態變量,
  因為"Hello world!"這個字符串在函數 s1和s2 中都引用了,但在內存中卻只有一份拷貝,這與靜態變量性質相當神似。

 

 


注意!

本站转载的文章为个人学习借鉴使用,本站对版权不负任何法律责任。如果侵犯了您的隐私权益,请联系我们删除。



 
粤ICP备14056181号  © 2014-2021 ITdaan.com