常量变量数据类型

C语言学习笔记–基础篇

打印 --printf（）

#include<stdio.h>
int main()
{
printf("hello world!\n");//\n换行
return0;
}

printf: 格式化输出

函数原型：

#include <stdio.h>
...
int printf ( const char * format, ... );

format 参数

format 参数是一个格式化字符串，由格式化占位符和普通字符组成。

格式化占位符（以 % 开头）用于指明输出的参数值如何格式化。

格式化占位符的语法如下：

%[flags][width][.precision][length] specifier

每一个格式化占位符均以 % 开始，以转换字符结束。

**specifier（转换字符，必选）**的内容及含义如下：

转换字符	参数类型；转换结果
c	char；字符
d	int；有符号十进制整数
i	同上
e	double；以指数形式输出单、双精度浮点数（小写 e）
E	同上（大写 E）
f	double；以小数形式输出单、双精度浮点数
g	double；以 %f 或 %e 中较短的输出宽度输出单、双精度浮点数（指数显示小写 e）
G	同上（指数显示大写 E）
o	unsigned int；无符号八进制（无前导 0）
s	char *；字符串
u	int；无符号十进制
x	unsigned int；无符号十六进制（无前导 0x）
X	同上（无前导 0X）
p	void *；指针值
n	int *；存放已写字符的个数
%	不进行参数转换；% 自身

flags（标志，可选）的内容即含义如下：

标志	含义
-	指定被转换的参数在其字段内左对齐（默认是右对齐）
+	指定在输出的数前面加上正负号
空格	如果第一个字符不是正负号，则在其前面加上一个空格
0	对于数值转换，当输出长度小于字段宽度时，添加前导 0 进行填充
> **	#

1. 如果转换字符为 o，则第一个数字为 0

2. 如果转换字符为 x 或 X，则指定在输出的非 0 值前加 0x 或 0X

3. 对于转换字符为 e、E、f、g 或 G 的情况，指定输出总是包含一个小数点。另外，对于转换字符为 g 或 G，还指定输出值尾部无意义的 0 将被保留

4. 注：flags 可同时出现多个，且无顺序要求。 |

width（宽度，可选）是一个数值，用于指定最小字段的宽度

转换后的参数输出宽度至少要达到这个数值。如果参数的字符数小于该数值，则在参数左边（如果 flags 设置为 -，要求左对齐的话则在右边）填充一些字符。填充字符通常为空格，但是如果 flags 设置为 0，则填充字符为数字 0。

.precision（.精度，可选），通过点号（.）分隔字段的宽度和精度

• 对于字符串，它指定打印的字符的最大个数
• 对于整数，它指定打印的数字位数（必要时可加填充位 0 以达到宽度要求）
• 对于转换字符为 e、E 或 f，它指定打印的小数点后的数字位数
• 对于转换字符为 g 或 G，它指定打印的有效数字位数

length（长度修饰符，可选）的值可以是 h、hh、l、ll 或 L

• hh 表示将相应的参数按 signed char 或 unsigned char 类型输出
• h 表示将相应的参数按 short 或 unsigned short 类型输出
• l 表示将相应的参数按 long 或 unsigned long 类型输出
• ll 表示将相应的参数按 long long 或 unsigned long long 类型输出
• L 表示将相应的参数按 long double 类型输出

… 附加参数

该参数的个数由格式化字符串决定。

每个参数的值应当与前面格式化字符串中的占位符类型和位置一一对应。
返回值：

如果函数调用成功，返回值是实际打印的字符数（不包含表示字符串结束的 ‘\0’）；

如果函数调用失败，返回值是一个负数。

例子

#include <stdio.h>

int main()
{
        int a = 520;
        char b = 'I';
        float c = 3.14;
        double d = 3.141592653;

        printf("%d\n", a);
        printf("%c love you\n", b);
        printf("圆周率是：%.2f\n", c);
        printf("精确到小数点后9位的圆周率是：%11.9f\n", d);

        return 0;
}

转义字符

在 C 语言中，用双引号括起来的内容我们称之为字符串，也就是我们平时所说的文本。

字符串可以由可见字符和转义字符组成，例如：星号（*），就是可见字符。可见字符就是你输入什么，显示出来就是什么。

而你如果想将一个字符串分为两行来显示，那么你就需要使用到转义字符。

转义字符一般是表示特殊含义的非可见字符，以反斜杠开头：

#include<stdio.h>
int main()
{
printf("\n\
  ***   ***\n\
 *****  *****\n\
 *************\n\
  ***********\n\
    *******\n\
      ***\n\
       *\n");//\n\中后面的\表示下一行和开头连接起来
return 0;
}

----------------

  ***   ***
 *****  *****
 *************
  ***********
    *******
      ***
       *

输入函数 scanf（）

scanf 函数从标准输入流中读取格式化字符串。

函数原型：

#include <stdio.h>
...
int scanf(const char *format, ...);

参数解析：

1、format 参数

format 参数是一个格式化字符串，由格式化占位符和普通字符组成。

该格式化字符串指定如何处理读取到的数据：

• 空白字符：该函数将读取并忽略空白字符（空白字符包含空格、回车和制表符）；
• 除了格式占位符（% 开头）外的非空白字符：指定函数必须从输入流中读取到的字符，如果读取不匹配，则函数调用失败，并从匹配失败处截断输入流；
• 格式化占位符（% 开头）：用于指明获取的数据类型及位置。

格式化占位符的语法如下：

%[width] [length]specifier

每一个格式化占位符均以 % 开始，以转换字符结束。

specifier（转换字符，必选）的内容及含义如下：

转换字符	含义
c	读取一个字符
d	读取一个十进制整数，前边可以加上符号（+ 或 -）表示正负
i	1. 读取一个整数，前边可以加上符号（+ 或 -）表示正负 2. 0 开头表示八进制数，0x 开头表示十六进制数
e	读取一个以指数形式的单、双精度浮点数（小写 e）
E	同上（大写 E）
f	读取一个单、双精度浮点数（需要使用 lf），前边可以加上符号（+ 或 -）表示正负
g	同 f、e、E
G	同上（指数显示大写 E）
a	读取一个十六进制的浮点数（以 0x 或 0X 开头）
o	读取一个八进制整数，前边可以加上符号（+ 或 -）表示正负
s	读取一连串字符，直到遇到空白字符结束。
u	读取一个无符号的十进制整数
x	1. 读取一个十六进制整数，前边可以加上符号（+ 或 -）表示正负 2. 十六进制数以 0x 或 0X 开头
p	读取一个指针的值
[characters]	1. 匹配中括号括起来的字符集 2. 可以用小横杆（-）表示范围，比如 [0-9]
[^characters]	1. 匹配除了中括号括起来的字符集 2. 可以用小横杆（-）表示范围，比如 [0-9]
n	1. 存放已经读取的字符个数 2. 不消耗任何标准输入流的字符
%	表示匹配 % 自身

注1：除了 n，其他的每次读取都会至少消耗标准输入流中的一个字符。

注2：如果读取失败，则标准输入流截断于读取失败的位置。

星号（*）、width 和 length 是可选的。

• 星号（*）表示读取但忽略（读取但不保存）；
• width 指定当前读取操作的最大字符数；
• length 是用于限定不同类型的宽度，具体请参考下表：

length	d 或 i	u、o 或 x	f、e、g 或 a	c、s、[] 或 [^]	p	n
默认	int*	unsigned int*	float*	char*	void**	int*
hh	signed char*	unsigned char*				signed char*
h	short int*	unsigned short int*				short int*
l	long int*	unsigned long int*	double*	wchar_t*		long int*
ll	long long int*	unsigned long long int*				long long int*
j	intmax_t*	uintmax_t*				intmax_t*
z	size_t*	size_t*				size_t*
t	ptrdiff_t*	ptrdiff_t*				ptrdiff_t*
L			long double*

温馨提示：因为整理自官方文档，所以出现了很多暂时你还不认识的东东，不用怕，暂时忽视他们即可……

2、… 附加参数

该参数的个数由格式化字符串决定。

每个参数均为一个存储空间，并与面格式化字符串中占位符的类型和位置一一对应。

如果是一个普通的变量名，应在其名字前边加上 & 符号。

返回值：

如果函数调用成功，返回值是成功获取并填充到附加参数中的个数。

如果函数调用失败，返回值小于附加参数的个数（甚至是 0）。

如果读取到标准输入流的结尾处，则返回 EOF。

#include <stdio.h>
int main()
{
        char c;
        int i;
        int j;

        scanf("%c%d%x", &c, &i, &j);//j为16进制
        printf("变量c的值是：%c\n", c);
        printf("变量i的值是：%d\n", i);
        printf("变量j的值是：%#X（%d）\n", j, j);//#：指定另一种输出形式：转换字符为 x 或 X，则指定在输出的非 0 值前加 0x 或 0X
        return 0;
}

变量

变量和常量是程序处理的两种基本数据对象。

我们把要让 CPU 处理的数据都放在内存中，但如果你没有给他安排一个位置，而是随意存放，那么你在后边需要再次用到这个数据的时候，就再也找不到它了。所以变量的意义就是确定目标并提供存放的空间。

变量名

为了确定目标，我们需要给变量命名，一旦变量有了名字，我们就可以通过直呼其名的方式来获取它里边存放的数据。

C 语言变量命名需要遵守的规范

• C语言变量名只能是英文字母（A-Z，a-z）和数字（0-9）或者下划线（_）组成，其他特殊字母不行。下横线通常用于连接一个比较长的变量名，比如i_love_you
• 第一个字母必须是由英文字母或者下划线开头，也就是不能用数字开头。
• 变量名区分大小写。因为C语言是大小写敏感的编程语言，也就是大写的LOVE跟小写的love会被认为是不同的两个名字。在传统的命名习惯中，我们用小写字母来命名变量，用大写字母来表示符号常量名。
• 不能使用关键字来命名变量。

关键字

关键字就是 C 语言内部使用的名字，这些名字都具有特殊的含义。如果你把变量命名为这些名字，那么 C 语言君搞不懂你到底想干嘛了。

传统的 C 语言（ANSI C）有 32 个关键字：

1999年，ISO 发布 C99，添加了 5 个关键字：

2011年，ISO 发布 C11，添加了 7 个关键字：

C 语言常用的基本数据类型

• char —— 字符型，占用一个字节
• int —— 整型，通常反映了所用机器中整数的最自然长度
• float —— 单精度浮点型
• double —— 双精度浮点型

C 语言声明变量的语法

• int a; // 在内存中找到一个整型大小的位置，然后霸占起来，并给它命名叫 a
• char b; //在内存中找到一个字节大小的位置，然后霸占起来，并给它命名叫 b
• float c; //在内存中找到一个单精度浮点型数据大小的位置，然后霸占起来，并给它命名叫 c
• double d; //在内存中找到一个双精度浮点型数据大小的位置，然后霸占起来，并给它命名叫 d

#include<stdio.h>
int main()
{
	int a;
	char b;
	float c;
	double d;
	
	a=520;
	b='l';
	c=3.14;
	d=3.141592653;
	
	printf("我们对C语言的感情：%d\n",a);//%d表示整形转换
	printf("i %cove you\n",b);//%c表示字符型转换
	printf("pi:%.2f\n",c);//%f表示浮点型转换，单精度双精度都是一样的，.2f表示小数点后两位
	printf("pi:%11.9f\n",d);//前面的11表示总占位11，小数点后有9位
    return 0;
}
--------------------
我们对C语言的感情：520
i love you
pi:3.14
pi: 3.141592653

常量

C 语言中常见的常量

• 整型常量：520, 1314, 123
• 实型常量：3.14, 5.12, 8.97
• 字符常量
  • 普通字符：‘L’, ‘o’, ‘v’, ‘e’
  • 转义字符：’\n’, ‘\t’, ‘\b’
• 字符串常量：“LOVE”
• 符号常量：使用之前必须先定义

定义符号常量（宏定义）

符号常量的定义格式是：

#define 标识符 常量

其中这个 #define 是一条预处理命令（预处理命令都以"#"开头），我们也称为宏定义命令。它的功能就是把程序中所有出现的标识符都替换为随后的常量。

#include <stdio.h>

#define NAME "满天星"
#define BOSS "小仙女"
#define YEAR 2020
#define MONTH 9
#define DAY 20

int main()
{
        printf("今天是%d年%d月%d日\n", YEAR, MONTH, DAY);
        printf("%s是%s\n", NAME, BOSS);

        return 0;
}
---------------
今天是2020年9月20日
满天星是小仙女

标识符

在 C 语言中，标识符指的就是一切的名字。比如刚刚的符号常量名是标识符，变量名也是一个标识符。以及我们即将学到的函数、数组、自定义类型这些的名字都称之为标识符。

字符串常量

C 语言用一个特殊的转义字符来表示字符串的结束位置。这样当操作系统读取到这个转移字符的时候，就知道该字符串到此为止 了。

这个转义字符就是空字符：’\0’

数据类型

在 C 语言里，所谓的数据类型就是坑的大小。我们说变量就是在内存里边挖一个坑，然后给这个坑命名。那么数据类型指的就是这个坑的尺寸。C 语言允许使用的类型如下：

short 和 long

我们可以为这些基本数据类型加上一些限定符，比如表示长度的 short 和 long。比如 int 经过限定符修饰之后，可以是 short int，long int，还可以是 long long int（这个是 C99 新增加的）。

这里需要说的是，这里 C 语言并没有限制 int 的坑具体要挖多大，short int 或 long int 的坑又要挖多大。标准只是要求：short int <= int <= long int <= long long int。

sizeof 运算符

sizeof 用于获得数据类型或表达式的长度，它有三种使用方式：

sizeof(type_name); //sizeof(类型);
sizeof(object); //sizeof(对象);
sizeof object; //sizeof 对象;

signed 和 unsigned

还有一对类型限定符是 signed 和 unsigned，它们用于限定 char 类型和任何整型变量的取值范围。

signed 表示该变量是带符号位的，而 unsigned 表示该变量是不带符号位的。带符号位的变量可以表示负数，而不带符号位的变量只能表示正数，它的存储空间也就相应扩大一倍。默认所有的整型变量都是 signed 的，也就是带符号位的。

因此加上 signed 和 unsigned 限定符，四种整型就变成了八种：

[signed] short [int]

unsigned short [int]

[signed] int

unsigned int

[signed] long [int]

unsigned long [int]

[signed] long long [int]

unsigned long long [int]

取值范围

比特位和字节

CPU 能读懂的最小单位（只能存放 0 和 1）—— 比特位，bit，b

内存机构的最小寻址单位 —— 字节，Byte，B

关系：1Byte == 8bit

因此，一个字节可以表示最大的数是：11111111

二进制、十进制和十六进制

符号位

存放 signed 类型的存储单元中，左边第一位表示符号位。如果该位为 0，表示该整数是一个正数；如果该位为 1，表示该整数是一个负数。

一个 32 位的整型变量，除去左边第一位符号位，剩下表示值的只有 31 个比特位。

补码

计算机是用补码的形式来存放整数的值。

正数的补码是该数的二进制形式。

负数的补码需要通过以下几步获得：

• 先取得该数的绝对值的二进制形式
• 再将第1步的值按位取反
• 最后将第2步的值加1

二进制表示最大值和最小值

二进制数和十进制数之间的相互转换

二进制 -> 十进制

从二进制数转换到十进制数，我们使用“按权相加”的方法。

什么是“权”？

所谓“权”，即“位权”！

比如说一个八位的二进制数 0010 1010，从右往左（←），每个位的“位权”依次是 01234567，如下图所示：

下边是公式：

十进制数 == 依次将每个二进制位的值 * 2的位权次方再相加

如果符号位为 0，表示该数为正数，转换跟无符号数没什么两样。

如果符号位为 1，表示该数为负数，此时符号位的位权不变，但该位的权值应该乘以 -1 得到。

举个栗子，将有符号数 0011 1100 转换成十进制数，与无符号数的做法是一样的：

​ 0 * 2^7 + 0 * 2^6 + 1 * 2^5 + 1 * 2^4 + 1 * 2^3 + 1 * 2^2 + 0 * 2^1 + 0 * 2^0

== 32 + 16 + 8 + 4

== 60

然后如果符号位为 1，表示这是一个负数，比如 1011 1100，那么符号位的权值就应该乘以 -1 得到：

​ -1 * 2^7 + 0 * 2^6 + 1 * 2^5 + 1 * 2^4 + 1 * 2^3 + 1 * 2^2 + 0 * 2^1 + 0 * 2^0

== -128 + 32 + 16 + 8 + 4

== -68

在举个极端点的例子，比如 1000 0000：

​ -1 * 2^7 + 0 * 2^6 + 0 * 2^5 + 0 * 2^4 + 0 * 2^3 + 0 * 2^2 + 0 * 2^1 + 0 * 2^0

== -128

现在明白为啥 1000 0000 表示 -128 了吧~

十进制 -> 二进制

从十进制数转换到二进制数，我们使用“辗转相除”的方法。不过我们这里不是要求最大公约数，而是取其余数。

即将待转换的十进制数不断地除以 2，直到商为 0，将每次除得的余数倒序拼凑起来，便是对应的二进制数……

二进制数和十六进制数之间的相互转换

鉴于二进制和十六进制之间有着密不可分的暧昧关系，你只需要记住下边这个表格即可：

基本数据类型的取值范围

字符串和字符类型

字符类型和整型

字符类型事实上是一个特殊的整数类型

字符类型事实上是一个特殊的整型，因此它也有取值范围，signed char 的取值范围是 -128 ~ 127；unsigned char 的取值范围是 0 ~ 255。

字符类型与普通整数类型的不同之处

C 标准规定普通整数类型默认使用 signed 修饰符，但没有规定 char 的默认修饰符。因此，使用 signed 或 unsigned 修饰符，是由编译系统自行决定。

存放在字符类型中的变量，都可以被解释为 ASCII 字符表中的对应字符

标准 ASCII 字符表使用7位二进制数来表示所有的大写和小写字母，数字 0 到 9、标点符号， 以及在美式英语中使用的特殊控制字符。

其中，ASCII 字符表上的数字 0 ~ 31 以及 127（共 33 个）分配给了控制字符，用于控制像打印机等一些外围设备。这些是看不到的。数字 32 ~ 126 分配给了能在键盘上找到的字符，这些是所见即所得的。

ASCII

ASCII（American Standard Code for Information Interchange，美国标准信息交换代码）是基于拉丁字母的一套电脑编码系统，主要用于显示现代英语和其他西欧语言。它是现今最通用的单字节编码系统，并等同于国际标准 ISO/IEC 646。

标准 ASCII 字符表使用 7 位二进制数来表示所有的大写和小写字母，数字 0 到 9，标点符号，以及在美式英语中使用的特殊控制字符。

其中，ASCII 字符表上的数字 0~31 以及 127（共 33 个）分配给了控制字符，用于控制像打印机等一些外围设备：

二进制	十进制	十六进制	缩写	含义
0000 0000	0	00	NUL	空字符
0000 0001	1	01	SOH	标题开始
0000 0010	2	02	STX	文本开始
0000 0011	3	03	ETX	文本结束
0000 0100	4	04	EOT	传输结束
0000 0101	5	05	ENQ	请求
0000 0110	6	06	ACK	确认响应
0000 0111	7	07	BEL	响铃
0000 1000	8	08	BS	退格
0000 1001	9	09	HT	水平制表符
0000 1010	10	0A	LF	换行符
0000 1011	11	0B	VT	垂直制表符
0000 1100	12	0C	FF	换页符
0000 1101	13	0D	CR	回车键
0000 1110	14	0E	SO	取消变换（Shift out）
0000 1111	15	0F	SI	启动变换（Shift in）
0001 0000	16	10	DLE	数据链路转义
0001 0001	17	11	DC1	设备控制一（XON 激活软件速度控制）
0001 0010	18	12	DC2	设备控制二
0001 0011	19	13	DC3	设备控制三（XOFF 停用软件速度控制）
0001 0100	20	14	DC4	设备控制四
0001 0101	21	15	NAK	拒绝接收
0001 0110	22	16	SYN	同步空闲
0001 0111	23	17	ETB	区块传输结束
0001 1000	24	18	CAN	取消
0001 1001	25	19	EM	连接介质中断
0001 1010	26	1A	SUB	替换
0001 1011	27	1B	ESC	退出键
0001 1100	28	1C	FS	文件分区符
0001 1101	29	1D	GS	组群分隔符
0001 1110	30	1E	RS	记录分隔符
0001 1111	31	1F	US	单元分隔符
0111 1111	127	7F	DEL	删除

ASCII 字符表上的数字 32~126 分配给了能在键盘上找到的字符，当您查看或打印文档时就会出现：

二进制	十进制	十六进制	字符		二进制	十进制	十六进制	字符
0010 0000	32	20	空格		0101 0000	80	50	P
0010 0001	33	21	!		0101 0001	81	51	Q
0010 0010	34	22	"		0101 0010	82	52	R
0010 0011	35	23	#		0101 0011	83	53	S
0010 0100	36	24	$		0101 0100	84	54	T
0010 0101	37	25	%		0101 0101	85	55	U
0010 0110	38	26	&		0101 0110	86	56	V
0010 0111	39	27	’		0101 0111	87	57	W
0010 1000	40	28	(		0101 1000	88	58	X
0010 1001	41	29	)		0101 1001	89	59	Y
0010 1010	42	2A	*		0101 1010	90	5A	Z
0010 1011	43	2B	+		0101 1011	91	5B	[
0010 1100	44	2C	,		0101 1100	92	5C	\
0010 1101	45	2D	-		0101 1101	93	5D
0010 1110	46	2E	.		0101 1110	94	5E	^
0010 1111	47	2F	/		0101 1111	95	5F	_
0011 0000	48	30	0		0110 0000	96	60	`
0011 0001	49	31	1		0110 0001	97	61	a
0011 0010	50	32	2		0110 0010	98	62	b
0011 0011	51	33	3		0110 0011	99	63	c
0011 0100	52	34	4		0110 0100	100	64	d
0011 0101	53	35	5		0110 0101	101	65	e
0011 0110	54	36	6		0110 0110	102	66	f
0011 0111	55	37	7		0110 0111	103	67	g
0011 1000	56	38	8		0110 1000	104	68	h
0011 1001	57	39	9		0110 1001	105	69	i
0011 1010	58	3A	:		0110 1010	106	6A	j
0011 1011	59	3B	;		0110 1011	107	6B	k
0011 1100	60	3C	<		0110 1100	108	6C	l
0011 1101	61	3D	=		0110 1101	109	6D	m
0011 1110	62	3E	>		0110 1110	110	6E	n
0011 1111	63	3F	?		0110 1111	111	6F	o
0100 0000	64	40	@		0111 0000	112	70	p
0100 0001	65	41	A		0111 0001	113	71	q
0100 0010	66	42	B		0111 0010	114	72	r
0100 0011	67	43	C		0111 0011	115	73	s
0100 0100	68	44	D		0111 0100	116	74	t
0100 0101	69	45	E		0111 0101	117	75	u
0100 0110	70	46	F		0111 0110	118	76	v
0100 0111	71	47	G		0111 0111	119	77	w
0100 1000	72	48	H		0111 1000	120	78	x
0100 1001	73	49	I		0111 1001	121	79	y
0100 1010	74	4A	J		0111 1010	122	7A	z
0100 1011	75	4B	K		0111 1011	123	7B	{
0100 1100	76	4C	L		0111 1100	124	7C	|
0100 1101	77	4D	M		0111 1101	125	7D	}
0100 1110	78	4E	N		0111 1110	126	7E	~
0100 1111	79	4F	O

字符串

C 语言没有专门为存储字符串设计一个单独的类型，因为没必要。我们之前已经说过，字符串事实上就是一串字符。所以只需要在内存中找一块空间，然后存放一串字符类型的变量即可。

声明字符串的语法：

char 变量名[数量];

对其进行赋值，事实上就是对这一块空间里边的每一个字符变量进行赋值。我们通过索引号来获得每个字符变量的空间。

char name[5];//声明

name[0] = 'L';
name[1] = 'O';
name[2] = 'V';
name[3] = 'E';
name[4] = '\0';

当然，我们可以把声明和定义写在一块，语法是这样的：

char name[5] = {'L', 'O', 'V', 'E', '\0'};

其实，中括号（[]）里边的数量咱可以不写，编译器会自动帮你计算的。

char name[] = {'L', 'O', 'V', 'E', '\0'};

事实上可以直接在大括号写上字符串常量，字符串常量用双引号括起来：

char name[] = {"LOVE"};

使用字符串常量有个好处，那就是你不必亲自在末尾添加 ‘\0’，它会自动帮你加上。

最后，如果使用字符串常量的话，这个大括号也是可以省掉的：

char name[] = "LOVE";

   |                                                              |

字符串

C 语言没有专门为存储字符串设计一个单独的类型，因为没必要。我们之前已经说过，字符串事实上就是一串字符。所以只需要在内存中找一块空间，然后存放一串字符类型的变量即可。

声明字符串的语法：

char 变量名[数量];

对其进行赋值，事实上就是对这一块空间里边的每一个字符变量进行赋值。我们通过索引号来获得每个字符变量的空间。

char name[5];//声明

name[0] = 'L';
name[1] = 'O';
name[2] = 'V';
name[3] = 'E';
name[4] = '\0';

当然，我们可以把声明和定义写在一块，语法是这样的：

char name[5] = {'L', 'O', 'V', 'E', '\0'};

其实，中括号（[]）里边的数量咱可以不写，编译器会自动帮你计算的。

char name[] = {'L', 'O', 'V', 'E', '\0'};

事实上可以直接在大括号写上字符串常量，字符串常量用双引号括起来：

char name[] = {"LOVE"};

使用字符串常量有个好处，那就是你不必亲自在末尾添加 ‘\0’，它会自动帮你加上。

最后，如果使用字符串常量的话，这个大括号也是可以省掉的：

char name[] = "LOVE";

参考

鱼C论坛https://fishc.com.cn/forum.php?mod=forumdisplay&fid=329&filter=typeid&typeid=583