在 C 语言中，字符串有两种存储方式，一种是通过字符数组存储，另一种是通过字符指针存储。

一、字符常量：

 一个用单引号括起来的单个字符（或字符转义序列或三字母词）

实质（含义）：是一个整形值。属于四大基本数据类型（分别是整型，浮点型，指针，聚合类型）中的整型（integers）。

C语言字符常量与字符串常量

备注：字符常量和字符变量：

• 字符常量
  字符常量是用单引号括起来的一个字符，如'a'、'A'、'1'、'='。因此字符常量有以下特点：
  I. 字符常量只能用单引号括起来，不能用双引号或其他符号。
  II. 字符常量只能是单个字符，即单引号内只能有一个字符。
  转义字符是一种特殊的字符常量，有以下特点：
  I. 转义字符以反斜线"\"开头，后面跟一个或几个字符。
  II. 转义字符具有特定的含义，不同于字符原有的意义。
• 字符变量
  I. 字符变量的类型说明符为char，字符变量定义格式为：char a;、char a,b;
  II. 字符变量用来存储字符常量，字符值是以ASCII码的二进制形式存放在变量的内存单元之中的，如字符'x'的ASCII码是120，定义字符变量char a = 'x';，实际上字符变量a内存放120的二进制代码。若将整型值直接赋值给字符变量，如char a = 100;，实际上是将ASCII码为100的字符'd'赋值给了字符变量a。
  III. 字符型可看做一种特别短的整型
  类型说明符：[signed] char，表示的数值范围：-128 ~ 127，存储大小：1字节
  类型说明符：unsigned char，表示的数值范围：0 ~ 255，存储大小：1字节

字符型参与算术运算

由于字符型可看做一种特别短的整型，因此可以将字符型与整型进行算术运算。

#include <stdio.h>

int main(void)
{
    printf("%d\n", 'A'+2);
    printf("%c\n", 'A'+2);
}

以上程序输出：

67
C

字符型参与算术运算，实际上是将字符对应的ASCII码进行算术运算。字符'A'对应的ASCII码为65，应此'A'+2以十进制形式输出带符号整数的结果为67；而ASCII码值为67的字符为'C'，应此'A'+2以单个字符输出的结果为C。

\n——换行，

\t——tab,

\r——回车，

\f——换页，

\b——退格，

\ddd——1到3位8进制的数代表的字符

二、字符串常量：

 两种定义方式：

（字符数组）数组方式定义字符串：当数组名用于表达式中时，它们的值也是个指针常量。我们可以对它们进行下标引用、间接访问以及指针运算。

（字符串指针）指针常量定义字符串：当一个字符串常量出现在表达式中时，它的值是个指针常量。编译器把这些指定字符的一份拷贝存储在内存的某个位置，并存储一个指向第一个字符的指针。（一个是指针的地址，一个是字符串的地址）

1、

char str[] = "hello, world";
str[1] = 'a';

2、

char *str = "hello, world";
str[1] = 'a';

两个程序都可以编译，但第二个运行会出现段错误。

两个程序的区别在：

第一个程序的 str 属于初始化变量，str 如果是局部变量则指向栈上的内存区域，如果是 static 或全局变量则指向进程的 data 段内存区域。data 段权限是可读、可写；

第二个程序中 "hello, world" 是一个字符串面量，str 的确指向其地址，但该地址存在于在进程的 text 段，text 段除了保存常量还保存可执行代码，因此是不允许可写权限的，而是只允许可读、可执行权限。

 实例：

char p[] = "hello"; // 方式1

char *p = "hello"; // 方式2

char *p;
p = (char *)malloc(sizeof(char)*6);
strcpy(p, "hello"); // 方式3

这三种情况下：
方式1：所有6个char字符都连续的存放在栈区。内容可更改！
方式2："Hello"存在程序内存的常量区中，是编译时就固定下来的（不可更改），然后p是一个指向常量区"hello"的指针，p本身存在栈区。
方式3： malloc向堆申请了空间，p存放在栈区，指向malloc申请出来的地址，最后"hello"就被copy到了p所指向的地址。内容可更改！
从速度来看1中栈的数据都是直接读的，另外两种都需要通过指针间接读取，所以1显然是最快的。
我觉得首先如果字符串很小且确定，可以用1的写法，在栈区速度快。
如果字符串很大或者不确定，要知道栈区大小是有限的，所以采用3的动态分配比较好。
如果字符串被大量复用，其实可以采用2中写法，这样只要引用了常量区的同一字符串，他们将会共用同一块地址。（当然这种共用是合理的，因为那里的字符串是不可修改的，且到程序结束才会被释放）。

C语言字符串常量

示例代码：

#include <stdio.h>
#include <string.h>
int main() {
	printf("\t方式1……\n");
	char p0[] = "hello"; // 方式1
	printf("输出数组定义字符串：%s\n",p0);
	printf("输出数组定义字符串地址：%p\n",p0);
	//更改数组P0中的某一个元素
	p0[0] = 'H';
	printf("输出数组定义字符串：%s\n", p0);
	/*
	printf("\t方式2……\n");
	char *p1 = "hello"; // 方式2
	printf("输出指针定义字符串：%s\n", p1);
	printf("输出指针定义字符串地址：%p\n", &p1);
	//更改数组P1中的某一个元素
	p1[0] = 'H';
	printf("输出指针定义字符串：%s\n", p1);
	*/
	printf("\t方式3……\n");
	char *p2;// 方式3
	p2 = (char *)malloc(sizeof(char) * 6);
	strcpy(p2, "hello");
	printf("输出指针定义字符串：%s\n", p2);
	printf("输出指针定义字符串地址：%p\n", &p2);
	//更改数组P2中的某一个元素
	p2[0] = 'H';
	printf("输出指针定义字符串：%s\n", p2);
	return 0;
}

运行结果：

示例代码：

#include <stdio.h>
#include <string.h>
int main() {
	printf("\t方式1……\n");
	char p0[] = "hello"; // 方式1
	printf("输出数组定义字符串：%s\n",p0);
	printf("输出数组定义字符串地址：%p\n",p0);
	//更改数组P0中的某一个元素
	p0[0] = 'H';
	printf("输出数组定义字符串：%s\n", p0);
	
	printf("\t方式2……\n");
	char *p1 = "hello"; // 方式2
	printf("输出指针定义字符串：%s\n", p1);
	printf("输出指针定义字符串地址：%p\n", &p1);
	//更改数组P1中的某一个元素
	p1[0] = 'H';
	printf("输出指针定义字符串：%s\n", p1);
	
	printf("\t方式3……\n");
	char *p2;// 方式3
	p2 = (char *)malloc(sizeof(char) * 6);
	strcpy(p2, "hello");
	printf("输出指针定义字符串：%s\n", p2);
	printf("输出指针定义字符串地址：%p\n", &p2);
	//更改数组P2中的某一个元素
	p2[0] = 'H';
	printf("输出指针定义字符串：%s\n", p2);
	return 0;
}

 方式2可以编译，但运行会出现错误

运行结果：

 C语言中字符串常量的问题

如下示例，表明不同的字符串所在的内存位置不一样，故不相等

C/C++对字符串常量的处理策略

指针常量示例：

【 C 】彻底学会字符串常量

示例代码：

/*
#include <stdio.h>
int main() {
	char *p_char = "Hello World";
	printf("输出字符串：%s\n",p_char);
	printf("输出指针指向字符串的地址：%p\n",&p_char);
	printf("输出字符串：%c\n", p_char[1]);
	p_char[1] = 'H';
	printf("输出字符串：%s\n", p_char);
	//printf("输出指针指向字符串的地址：%p\n", &(p_char+1));
	char str[] = "I Love Beijing";
	printf("输出数组定义字符串：%s\n",str);
	printf("输出数组定义字符串地址：%p\n",str);

	return 0;
}
*/

/*
#include <stdio.h>
#include <string.h>
int main() {
	printf("\t方式1……\n");
	char p0[] = "hello"; // 方式1
	printf("输出数组定义字符串：%s\n",p0);
	printf("输出数组定义字符串地址：%p\n",p0);
	//更改数组P0中的某一个元素
	p0[0] = 'H';
	printf("输出数组定义字符串：%s\n", p0);
	
	printf("\t方式2……\n");
	char *p1 = "hello"; // 方式2
	printf("输出指针定义字符串：%s\n", p1);
	printf("输出指针定义字符串地址：%p\n", &p1);
	//技巧：
	printf("输出指针定义字符串：%c\n", *"hello");
	printf("输出指针定义字符串：%c\n", *("hello"+1));
	printf("输出指针定义字符串：%c\n", *(p1 + 1));
	//更改数组P1中的某一个元素
	p1[0] = 'H';
	printf("输出指针定义字符串：%s\n", p1);
	
	printf("\t方式3……\n");
	char *p2;// 方式3
	p2 = (char *)malloc(sizeof(char) * 6);
	strcpy(p2, "hello");
	printf("输出指针定义字符串：%s\n", p2);
	printf("输出指针定义字符串地址：%p\n", &p2);
	//更改数组P2中的某一个元素
	p2[0] = 'H';
	printf("输出指针定义字符串：%s\n", p2);
	return 0;
}
*/

#include <stdio.h>
#include <string.h>
int main() {
	printf("\t方式1……\n");
	char p0[] = "hello"; // 方式1
	printf("输出数组定义字符串：%s\n", p0);
	printf("输出数组定义字符串地址：%p\n", p0);
	//更改数组P0中的某一个元素
	p0[0] = 'H';
	printf("输出数组定义字符串：%s\n", p0);

	printf("\t方式2……\n");
	char *p1 = "hello"; // 方式2
	printf("输出指针定义字符串：%s\n", p1);
	printf("输出指针定义字符串地址：%p\n", &p1);
	//技巧：
	printf("输出指针定义字符串：%c\n", *"hello");
	printf("输出指针定义字符串：%c\n", *("hello" + 1));
	printf("输出指针定义字符串：%c\n", *(p1 + 1));
	//更改数组P1中的某一个元素
	p1[0] = 'H';
	printf("输出指针定义字符串：%s\n", p1);


	return 0;
}

运行结果：

 

 C语言字符常量与字符串常量

来自知乎的提问：

为什么char *a="xxxxx", *b="xxx"; strcpy(a, b);的用法不行？