字符串简介
在C语言中，字符串实际上是使用空字符\0结尾的一维字符数组。因此，\0是用于标记字符串的结束。
空字符（Null character）又称结束符，缩写NULL，是一个数值为0的控制字符，\0是转义字符，意思是告诉编译器，这不是字符0，而是空字符。
下面的声明和初始化创建了一个RUNOOB字符串。由于在数组的末尾存储了空字符\0，所以字符数组的大小比单词 RUNOOB 的字符数多一个。
char site[7] = {'R', 'U', 'N', 'O', 'O', 'B', '\0'};
依据数组初始化规则，您可以把上面的语句写成以下语句：
char site[] = "RUNOOB";
以下是 C/C++ 中定义的字符串的内存表示：
其实，您不需要把null字符放在字符串常量的末尾。C编译器会在初始化数组时，自动把\0放在字符串的末尾。
C语言中字符串的本质：指针指向头、固定尾部的地址相连的一段内存
C语言中字符串有3个核心要点：第一是用一个指针指向字符串头；第二是固定尾部（字符串总是以'\0'来结尾）；第三是组成字符串的各字符彼此地址相连。
'\0'作为一个特殊的数字被字符串定义为（幸运的选为）结尾标志。产生的副作用就是：字符串中无法包含'\0'这个字符。这种思路就叫“魔数”（魔数就是选出来的一个特殊的数字，这个数字表示一个特殊的含义，你的正式内容中不能包含这个魔数作为内容）。看这道题：
注意，如果想通过字符数组来创建字符串，必须手动在末尾添加'\0'，如下所示：
如果没有添加末尾的'\0'，可能会出现无法预料的结果：
运行结果：
对于直接字符串形式来说，虽然\0是自动加上的。但是在长度定义时，也要算上它，如果不算上，也可能会出错。
运行结果：
字符串的底层实现
C语言没有原生字符串类型
很多高级语言像java、C#等就有字符串类型，有个String来表示字符串，用法和int这些很像，可以String s1 = "linux";来定义字符串类型的变量。
C语言没有String类型，C语言中的字符串是通过字符指针来间接实现的。
C语言使用指针来管理字符串
C语言中定义字符串方法：char *p = "linux";此时p就叫做字符串，但是实际上p只是一个字符指针（本质上就是一个指针变量，只是p指向了一个字符串的起始地址而已）。
注意：指向字符串的指针和字符串本身是分开的两个东西
char *p = "linux";在这段代码中，p本质上是一个字符指针，占4字节；"linux"分配在代码段，占6个字节；实际上总共耗费了10个字节，这10个字节中：4字节的指针p叫做字符串指针（用来指向字符串的，理解为字符串的引子，但是它本身不是字符串），5字节的用来存linux这5个字符的内存才是真正的字符串，最后一个用来存'\0'的内存是字符串结尾标志（本质上也不属于字符串）。
字符串和字符数组
我们有多个连续字符（比如"linux"）需要存储，实际上有两种方式：第一种就是字符串；第二种是字符数组。
字符数组a和字符串p，char a[];int *p;——a和p都是指向字符串的首元素。
这两种方式有何区别？
sizeof(数组名)得到的永远是数组的大小，和数组中有无初始化，初始化多、少等是没有关系的。
char *p = "linux"; sizeof(p)得到的永远是4，因为这时候sizeof测的是字符指针p本身的长度，和字符串的长度是无关的。字符数组与字符串的本质差异（内存分配角度）
字符数组char a[] = "linux";来说，定义了一个数组a，数组a占6字节，右值"linux"本身只存在于编译器中，编译器将它用来初始化字符数组a后丢弃掉（也就是说内存中是没有"linux"这个字符串的，它只有一个个字符）；这句就相当于是：char a[] = {'l', 'i', 'n', 'u', 'x', '\0'};字符串char *p = "linux";定义了一个字符指针p，p占4字节，分配在栈上；同时还定义了一个字符串"linux"，分配在代码段；然后把代码段中的字符串（一共占6字节）的首地址（也就是'l'的地址）赋值给p。
总结对比：字符数组和字符串有本质差别。字符数组本身是数组，数组自身自带内存空间，可以用来存东西（所以数组类似于容器）；而字符串本身是指针，本身永远只占4字节，而且这4个字节还不能用来存有效数据，所以只能把有效数据存到别的地方，然后把地址存在p中。
也就是说字符数组自己存那些字符；字符串一定需要额外的内存来存那些字符，字符串本身只存真正的那些字符所在的内存空间的首地址。注意：
数组字符串的变量和字符串（字符形式）都在栈上，是可以修改的；
指针字符串的指针变量在栈上，但是字符串是以常量的形式存在代码段，是不能修改的。
验证如下：
字符数组形式：
#include <stdio.h>
int main()
{
int i = 0;
char a[] = "Hello World!";
a[5] = '-';
printf("Result is:");
for(i;i < 11;i++)
{
printf("%c",a[i]);
}
return 0;
}
//Result is:Hello-World指针形式：
#include <stdio.h>
int main()
{
char *a = "Hello World!";
*(a + 5) = '-';
printf("Result is:", *(a + 5));
return 0;
}
//3 Segmentation fault (core dumped) ./a.out由上述对比可知，如果修改指针形式的字符串，则会触发段错误。
问题：如果定义了多个指针变量，都是同一个字符串，那这些指针都会指向同一个地址吗？也就是说，相同的字符串只有一份。
#include <stdio.h>
int main()
{
char *a = "Hello World!";
char *b = "Hello World!";
char c[] = "Hello World!";
char d[] = "Hello World!";
char *e = "Hello World!";
printf("Result is: %x\n", a);
printf("Result is: %x\n", b);
printf("Result is: %x\n", c);
printf("Result is: %x\n", d);
printf("Result is: %x\n", e);
return 0;
}
/*
Result is: 402004
Result is: 402004
Result is: aadaa80b
Result is: aadaa7fe
Result is: 402004
*/由上述结果可知，指针形式生成的字符串，在内存中只有一份。都是指向同一个地址。
字符数组形式的字符串，会分配不同的地址，一般是连续的。比如上面的两个字符数组字符串之间就是连续的。
另外，如果想要char a[] = "happy";形式中，元素不能被修改，则可以增加const进行修改，此时，和char *a = "happy";等效。
示例如下：
#include <stdio.h>
int main()
{
const char a[] = "happy";
a[0] = 'H';
/* 我的第一个 C 程序 */
printf("Hello, World! %c\n", a[0]);
return 0;
}运行结果：
补充
我们知道，可以这样定义字符串，char *p = "stm32";
要注意，不是说这里的p表示的是个字符串指针，它仍然是一个字符指针，这个指针所指向的是字符串“stm32”的首字母的地址。如果直接解引用，*p是s
#include <stdio.h>
int main()
{
char *p = "stm32";
/* 我的第一个 C 程序 */
printf("Hello, World! %c\n", *p); //Hello, World! s
return 0;
}如果要访问字符串的各个字母，就要*(p + 1)/*(p + 2)/*(p + 3)……以此类推。
反过来，如果将某个字符串强制转换成char *，那么得到的也是这个字符串的首元素的地址，示例：
#include <stdio.h>
int main()
{
char *p = (char *)"stm32";
/* 我的第一个 C 程序 */
printf("Hello, World! %c\n", *p); //Hello, World! s
return 0;
}所以说，根本就没有真正的字符串类型，都是形式上的“障眼法”。
同理，把某个数强转成结构体指针，那么，所赋予的就是结构体首元素的首地址。
比如：
字符串和字符数组
字符 '0' 和 '\0' 及整数 0 的区别
字符 '0'：char c = '0'; 它的 ASCII 码实际上是 48，内存中存放表示：00110000。
字符 '\0'： ASCII 码为 0，表示一个字符串结束的标志。这是转义字符（整体视为一个字符）。由于内存中存储字符，依然是存储的是对应字符集的字符编码，所以内存中的表现形式为 00000000。ASCLL值0表示空字符，空字符就是平时所说的 ‘\0’。
整数 0 ： 内存中表示为 00000000 00000000 00000000 00000000，虽然都是 0，但是跟上面字符 '\0' 存储占用长度是不一样的。
补充：再次强调下数组形式字符串和指针形式字符串的区别
记录本小节内容的背景是这样的：
我有个结构体，里面有些参数是字符串，按照我一开始的想法，直接就是定义了char *str;
后来要给结构体重新赋值，可是出现了问题，定位了好久也没什么进展。
后来突然想起来，char *str定义的字符串放在代码区，是不能被改变的，所以，如果结构体里的字符串是希望被改变的，就不能定义成char *str的形式。
如果不能被定义成char *str的形式，那就肯定要定义成字符数组的形式。
于是我在结构体里定义了一个char str[]，结果定义的地方报错，我试着调整下，加了个长度，变成了char str[3]，恢复正常。可见，结构体里的每个变量，都要有固定的长度，要不然编译器就不知道到底要为它分配多少内存。char *s定义了一个char型的指针，它只知道所指向的内存单元，并不知道这个内存单元有多大。
注意，char *s类型初始化时是可以赋值的，但是之后就不能再被改变了。
既然解决了类型定义的问题，那么怎么来使用这个变量的。
既然是字符数组，那么赋值就需要注意。
数组如果一开始不初始化，那么之后就不能直接初始化，需要一个一个地赋值。
就算一开始直接初始化，后面要改变值的话，也要一个一个地赋值。
str[0] =
str[1] =
str[2] =
而且，这样的话，也不会自动在末尾添加'\0'，也就是说，不会被当做字符串来看待，而是当做一个一个的字符来看待。
关于这一点，结构体也一样，如果一开始不直接初始化，那么后面就要一个一个地初始化。
如果是这样的话，那就比较麻烦了。
有一点需要注意，（结构体变量.arr）得到的就是常规arr效果的指针。此时，直接操作的就是一个指针。
有什么办法能够直接赋字符串呢？
可以使用memcpy或者strcpy函数来赋值。
字符串的话，推荐使用strcpy，因为str开头的函数会处理'\0'，如果使用mem系列的话，就需要指定一个长度，而有时候长度是不固定的，就可能会因此多出一些空白符号。
比如：
strcpy(structVar.str，"100")，这个函数会将"100"连带末尾的结束符都赋值到目标指针处。
把字符串strcpy到这个指针开头的存储空间，并且有'\0'结尾。
注意：如果就是定义了字符类型的指针呢？char *p; *p = 'a'，这样是可以的，因为此时它就是一个普通的字符指针，而不是一个字符串，编译器不会当做字符串来处理。
其实仔细看看字符串函数里的例程，就会发现，基本上都是定义成字符数组。
只有在确定不会改变时，才会使用char *来定义字符串，而且，这种也可以通过const修饰字符数组来实现。或者，在函数参数里，通常都是以char *的形式来传递，但是，其通常所需要的也就是一个数组的名称，也就是数组首元素的字符指针，这才是char *出现得比较多的地方，但本质上，传递的还是数组的起始点。有时，在接受一个字符指针时，也会自己定义一个char *，这和参数里的用法是一样的。
有个问题，直接写的字符串是哪种类型的？
就是直接在程序里写一个"string"
好像没有直接写的，都是赋值的形式，只不过传给函数时，看起来好像没有类型，其实在函数形参中就有。直接传个字符串过去，底层应该是char *形式的，不可更改的。
今天在传值时，我在函数里面直接将数组名传给了另外一个数组名，以为这样就能将数组里的内容传递到另一个数组了，其实，这传的就是一个指针，而且，改变了另一个数组所指向的位置，当函数退出时，变量出栈，其所指向的就是一个不定值的区域。
我所希望的复制操作，应该通过strcpy或者memcpy来实现，切记。
注意：结构体里的字符串一定要设置长度尽可能大，最低要求是刚好够用，要不然当字符串多的时候，就会造成元素之间的存储空间相互覆盖的问题。
