程式師世界 >> 編程語言 >> C語言 >> 關於C語言 >> C語言中字符串常量到底存在哪了？

C語言中字符串常量到底存在哪了？

編輯：關於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"));

}