C語言中字串常量到底存在哪了?
常量儲存總結
區域性變數、靜態區域性變數、全域性變數、全域性靜態變數、字串常量以及動態申請的記憶體區
1、區域性變數儲存在棧中
2、全域性變數、靜態變數(全域性和區域性靜態變數)儲存在靜態儲存區
3、new申請的記憶體是在堆中
4、字串常量也是儲存在靜態儲存區
補充說明:
1、棧中的變數記憶體會隨著定義所在區間的結束自動釋放;而對於堆,需要手動free,否則它就一直存在,直到程式結束;
2、對於靜態儲存區,其中的變數常量在程式執行期間會一直存在,不會釋放,且變數常量在其中只有一份拷貝,不會出現相同的變數和常量的不同拷貝。
===============================================
關於字串常量,下面有篇文章解釋的很清晰:
char *c="zhouming";
書上說: "zhouming"這個字串被當作常量而且被放置在此程式的記憶體靜態區。
c為一個字元型指標,若為區域性變數,則儲存在棧內,該指標變數裡面存了個地址,
該地址為字串中第一個字母Z的地址。
當使用printf()輸出時,格式化時選擇%s,會輸出zhouming,這是printf遇到結尾符號‘\0’即停止顯示列印。
字串“zhouming”是個常量,儲存在一片連續的記憶體中,末尾有結尾符表示字串的結束。
那一般的int i=1;
所有的字元竄常量都被放在靜態記憶體區
因為字串常量很少需要修改,放在靜態記憶體區會提高效率
例:
char str1[] = "abcd";
char str2[] = "abcd";
const char str3[] = "abcd";
const char str4[] = "abcd";
const char *str5 = "abcd";
const char *str6 = "abcd";
char *str7 = "abcd";
char *str8 = "abcd";
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是指標,它們指向相同的常量區域。,"abcd"被儲存在靜態資料區,而且是全域性的,
問題的引入:
看看下面的程式的輸出:
#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型別。如下:
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 中都引用了,但在記憶體中卻只有一份拷貝,這與靜態變數性質相當神似。
另外還有個實驗:
[cpp]
#include <stdio.h>
#include <stdlib.h>
#include <math.h>
int main()
{
char *b;
char *c;
char a[]="chenhuijie";
b="chenhuijie";
c="chenhuijie";
printf("%d,%d,%d,%d\n",b,a,c,&("chenhuijie"));
}
#include <stdio.h>
#include <stdlib.h>
#include <math.h>
int main()
{
char *b;
char *c;
char a[]="chenhuijie";
b="chenhuijie";
c="chenhuijie";
printf("%d,%d,%d,%d\n",b,a,c,&("chenhuijie"));
}
實驗結果為:
4282272,1244988,4282272,4282272
請按任意鍵繼續. . .
對了,字元常量‘a’
sizeof(‘a’)
為4,及一個字長。