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，及一个字长。

时间： 2024-10-28 14:14:40

C语言中字符串常量到底存在哪了？的相关文章

一起talk C栗子吧（第一百六十五回：C语言实例--C语言中的常量）

各位看官们,大家好,上一回中咱们说的const关键字的例子,这一回咱们说的例子是:C语言中的常量 .闲话休提,言归正转.让我们一起talk C栗子吧! 看官们, 我们在上一回中介绍了const关键字,大家都知道被const修饰的都是常量.提到常量,我们在程序中经常使用它,这一回中我们一起看看C语言中的其它常量. 大家都知道,常量的值是固定的,而且不能被修改.在C语言中,一共有四种实现常量的方式,它们分别是: 字面常量 宏 const 枚举. 接下来我们分别介绍这四种实现常量的方式. 字面常量:字

c语言中字符串操作的工具类

 1.编写头文件 #define _CRT_SECURE_NO_WARNINGS //#pragmawarning(disable:4996) #include <stdio.h> #include <stdlib.h> #include <string.h> struct CString { char *p;        //保存字符串首地址 int reallength; //实际长度 }; typedef struct CString mystring;//

C语言中字符串如何转换为二进制、八进制、十进制、十六进制

在C语言某个程序当中需要把文本16进制转换成对应的16进制数,比如字符串"0x1a"转换成10进制的26,可以用以下函数来实现 相关函数: atof, atoi, atol, strtod, strtoul表头文件: #include <stdlib.h>定义函数: long int strtol(const char *nptr, char **endptr, int base):函数的解释说明 这个函数会将参数nptr字符串根据参数base来转换成长整型数.参数base

D语言中字符串的操作

字符串的操作在软件开发中是特别重要的一个事情,因为基本上的编程都会使用到字符串,字符串操作的好坏决定着一个语言的好与差.在我做过的一个项目中曾经就出现过字符串操作性能问题. D语言字符串有 string,wstring,dstring三种类型,在D语言中字符串是使用字符数组定义的,三种类型分别对应char,wchar,dchar.char只有一个字节,wchar为双字节,dchar为三字节.对字符串的操作也相当于是对数组的操作,这跟其它语言不一样,C++中字符串是以string类来进行封装,它的

c语言中字符串的匿置 超级简单

#define _CRT_SECURE_NO_WARNINGS #include<stdio.h> #include<stdlib.h> #include<string.h> void main() { char * src = "hello,world"; printf("%d", src[10]); char *dest = NULL; //开辟内存空间 然后多开辟一个用来存储字符串的结束符 dest= (char *)mal

go语言中字符串分割

go语言中字符串的分割分以下几种: 1.根据空格键进行分割 方法:strings.Fields(s string) []string s:要分割的字符串 返回结果为[]string 例: s:=" ab cd          ef gh ij kl " arr:=strings.Fields(s) fmt.Printf("arr:%q\n",arr) 结果为:arr:["ab" "cd" "ef" &qu

c语言中字符串跨行书写的问题

字符串常量定义时的换行问题 如果我们在一行代码的行尾放置一个反斜杠,c语言编译器会忽略行尾的换行符,而把下一行的内容也算作是本行的内容.这里反斜杠起到了续行的作用.        如果我们不使用反斜杠,当我们试图初始化一个跨多行的字符串是,c语言编译器就会发出警告.如下面的语句所示:char letters[] = {"abcdefghijklmnopqrstuvwxyz  ABCDEFGHIJKLMNOPQRSTUVWXYZ"};      但是我们在行尾使用反斜杠, 那么就可以吧字

Java中字符串常量池的陷阱

public class TestCase { static String ab = "ab"; static String getA() { return "a"; } static String getAB() { return "ab"; } public static void main(String[] args) { // 1 String _ab = new String("ab"); System.out.pr

浅谈JAVA中字符串常量的储存位置

在讲述这些之前我们需要一些预备知识: java中的内存被分成以下部分: 1.栈区:由编译器自动分配释放,具体方法执行结束后,系统自动释放JVM内存资源. 其作用有保存局部变量的值,包括:1.用来保存基本数据类型的值:2.保存类的实例,即堆区对象的引用(指针).也可以用来保存加载方法时的帧. 2.堆区:一般由程序员分配释放,JVM不定时查看这个对象,如果没有引用指向这个对象就回收. 其作用为用来存放动态产生的数据,比如new出来的对象.注意创建出来的对象只包含属于各自的成员变量,并不包括成员方法.