关于C之字符串两种声明方式的核心区别及内存分配方式的静态/堆/栈

比如有如下声明和初始化：

const char pets[12] = "nice cat.";

由于字符串本质上是一个字符数组，以上声明是下面的简版：

const char pets[12] = {'n','i','c','e',' ','c','a','t','.','\0','\0','\0'};

对于没初始化的元素会自动初始化为'\0'(关于C之空字符与空指针)（注：如果完全没有初始化任何一个元素，则不是0而是垃圾数据）。以上声明在内存中的表示如下图：

字符串末尾是有个隐藏的'\0'作为结束标志的，所以"x"<=>{'x','\0'}，即声明的字符数组大小size只能容纳size-1个元素。

对于数组来说，变量名即是指向首个元素的指针。可以用声明一个指向字符串的指针：

const char * ptstr = "nice cat.";

以上声明与下面的很相似：

const char arr[] = "nice cat.";

这两种声明方式，字符串自行决定了它的大小。

从上面可知，用字符数组和指针声明可以等效化：使用指针声明字符串，也可以用下标去访问每个元素；使用字符数组声明字符串，也可以用指针游标去访问每个元素。

要注意的一点就是判断结尾'\0'，所以对于char arr[10]，访问arr[9]是没意义的，因为是空字符null('\0')。即，里面能装有效字符为9而不是10个。

对于上面的声明，下面的操作是等效的：

// 等效值
ptstr[0] == *ptstr == 'n'，ptstr[N] == *(ptstr+N)（其中N<strlen(ptstr)）

*arr == arr[0] == 'n'，*(arr+N) == arr[N]（其中N<sizeof(arr)）

// 等效赋值
错误(下文会分析)：ptstr[M] = 'A' <=> *(ptstr+M) = 'A'（其中M<strlen(ptstr)）

*(arr+M) = 'A' <=> arr[M] = 'A'（其中M<sizeof(arr)）

注：声明字符串，其最后总被自动添加上结束符'\0'。

关于字符串常量，如:"Hello World",它们被放在静态储存类别里，也就是说如果你在一个函数里面使用了这个字符串常量，这个字符串只被存储一次直至函数结束，即使函数被调用很多次。

通过下面例子看一下字符串的地址，这样更直观：

#define MSG "I'm special."
#include <stdio.h>
int main() {
    char ar[] = MSG;
    char *pt = MSG;
    printf("address of \"I'm special\": %p \n", "I'm special");
    printf(" address ar: %p\n", ar);
    printf(" address pt: %p\n", pt);
    printf(" address of MSG: %p\n", MSG);
    printf("address of \"I'm special\": %p \n", "I'm special");
    return 0;
}

OS X10上运行结果： 

address of "I'm special": 0x100000f0c
              address ar: 0x7fff5fbff8c7
              address pt: 0x100000ee0
          address of MSG: 0x100000ee0
address of "I'm special": 0x100000f0c

Windows32上运行结果：

address of "I'm special": 00BF7B40
              address ar: 0028F71C
              address pt: 00BF7B30
          address of MSG: 00BF7B30
address of "I'm special": 00BF7B40

从结果可以看到，同一个字符串常量，尽量在一个主函数里不同的地方打印两次，地址仍是一样的，因为对于一样的字符串常量，本编译器选择同一个存储地址存储它们，其实编译器有使用一个或多个地址存储字符串常量的自由，在其他编译器可能结果不同，不过在OS X和Windows系统上运行结果是同一地址，应该基本上就是相同的。这里还要注意一点：ar使用的是动态内存，字符串常量MSG使用的是静态内存，它们不仅地址不同甚至连表示内存地址的位数都可能不同。

以下是等效的吗？

char* p = "abcd"; <=> const char* p = "abcd"

看下面例子：

 直接修改指针指向数据内容，Exception Thrown:write access violation.(即只读不可写)。与加const效果一致。可见，上面代码是等效“<=>”的。

可以肯定的是pt与MSG地址相同，因为声明了pt就是直指MSG的首地址的。直接使用“I'm special”，它是存储在常量区，不可修改。用指针赋值给它，表示这个指针指向的地址是这个常量字符串的地址。

但ar不也是指向MSG首地址吗？不是等效吗？为何地址不同？这里仔细分析一下原理：

从两个小例子就能看出char *a与char a[]的区别：

#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
int main() {
	char* d = "0123456789";
	char s[20] = "hello";

	strcat(s, d);
	printf("%s\n", s);
	return 0;
}

hello0123456789

以上将char *d拼接到char s[20]上，输出正确。

#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
int main() {
	char* d = "0123456789";
	char s[20] = "hello";

	strcat(d, s);
	printf("%s\n", s);
	return 0;
}

 以上将char s[20]拼接到char *d上，程序出错。

在Windows7 x86 VS2019环境下运行，出错信息如下：

0x0F89EE39 (ucrtbased.dll)处(位于 HelloWorld.exe 中)引发的异常: 0xC0000005: 写入位置 0x00967B3A 时发生访问冲突。
_____________________________________________________________
在OS X10 Xcode环境下运行，出错信息如下：

Thread 1: EXC_BAD_ACCESS (code=2, address=0x100000f94)
_____________________________________________________________
在其他C编辑器中有如下出错信息：
Segmentation fault

上面两个例子，仅仅是把指针声明的字符串和字符数组声明的字符串变量互换了位置而已，但错误就出现了。

把字符串加到指针所指的字串上去，出现段错误，本质原因：*d="0123456789"存放在常量区，是无法修的（所以经常要加const声明指向字符串的指针，使代码更清晰）。比如*d='9'就出现异常（Win VS2019：“引发了异常: 写入访问权限冲突。d 是 0x11A7B30。”）。而数组是存放在栈中，是可以修改的。两者区别如下：

一. “读” “写” 能力

• char *a = "abcd";  此时"abcd"存放在常量区。通过指针只可以访问字符串常量，而不可以改变它(相当于声明前面加了const)。
• 而char a[20] = "abcd"； 此时 "abcd"存放在栈。可以通过下标或指针去访问和修改数组内容。

二. 赋值时刻

• char *a = "abcd"; 是在编译时就确定了（因为是常量）。
• 而char a[20] = "abcd"； 在运行时确定。

三. 存取效率

• char *a = "abcd"; 存于静态存储区，对栈的访问比静态存储区的快，因此慢。
• 而char a[20] = "abcd"； 存于栈上，因此快。

之所以出现“Segmentation fault(段错误)”或“写入访问权限冲突”，是因为指针所指向的字符串是静态的，只有“读”的本事，不可以改变/“写”。

通过分析两种声明数组的方式的区别，我们再回过头看之前例子中的疑问，是不是就已经得到答案了。

我们再看下面的赋值语句，来揭示char []的一个隐藏限制：

char* d = "0123456789";
char s[20] = "hello";
char s2[20] = "hello";

*d='9';// 运行报错：写入访问权限冲突
d = s; // 正确
s = s2;// 还没Build就报错：表达式必须是可修改的左值
s = d; // 还没Build就报错：表达式必须是可修改的左值

原因是：char数组名是指针没错，但它是指针常量， 是不能修改的。这与编译器报错信息也是匹配的。

由此我们可以看到：char *ptstr与char arr[]都自带了一个默认const关键字：一个是常量指针；一个是指针常量。即：

char *ptstr = "hello"; <=> char const * ptstr = "hello";// 常量指针(指向可变，内容不可变)
char arr[10] = "hello"; arr <=> char * const arr;// 指针常量(指向不能变，内容可变)

其实只要是针对数组(不是非得字符数组)，这个规则都是存在的，即数组名是一个指针常量。 

常量指针：即指针所指向的内存地址里面的内容是常量，不能修改。但指针也可指向其他的地址，只是所指向的地址内容是常量；

指针常量：即指针本身是常量，不能修改，指针不能指向其他地址。但指针所指向的地址内容是可修改的。

其实声明顺序很好记：“const * x”->顺序读下去:“常量 指针 x”；“* const x”->顺序读下去:“指针 常量 x”；“const * const x”->“常量指针常量”。

现在，我们看一下内存分配的方式：

内存分配有三种：静态存储区、堆区和栈区。它们的功能不同，对它们使用方式也就不同。

1. 静态存储区：内存在程序编译的时候就已经分配好，这块内存在程序的整个运行期间都存在。它主要存放静态数据、全局数据和常量。
2. 栈区：在执行函数时，函数（包括main函数）内局部变量的存储单元都可以在栈上创建，函数执行结束时这些存储单元自动被释放。栈内存分配运算内置于处理器的指令集中，效率很高，但是分配的内存容量有限。（任何变量都处于栈区，例如int a[] = {1, 2},变量a处于栈区。数组的内容也存在于栈区。）
3. 堆区：亦称动态内存分配。程序在运行的时候用malloc或new申请任意大小的内存，程序员自己负责在适当的时候用free或delete释放内存。动态内存的生存期可以由我们决定，如果我们不释放内存，程序将在最后才释放掉动态内存。 但是，良好的编程习惯是：如果某动态内存不再使用，需要将其释放掉，并立即将指针置为NULL，防止产生野指针。