一、注释
注释 就是对代码进行解释说明的文字，注释的内容不会参与编译和运行，仅仅是对代码的解释说明。在 C语言 中注释主要分为以下两类：
- 单行注释：
//，注释内容从 // 始到本行和结尾 - 多行注释：
/* */，注释内容以 /* 开头，以 */ 结尾，可以注释多行
/**
* 导入一个头文件 stdio.h
* std是一个标准输入输出标准库，i指的是input，o指的是output，.h是指头文件的意思
* <>表示导入系统的文件，""表示导入自定义文件
*/
#include <stdio.h>
/**
* int 数据类型 整型，如果出现再函数中表示函数的返回值
* main 程序的主函数，程序有且只有一个主函数
* () 里面表示函数的参数，函数的参数可以有多个，中间用，分隔
* {} 里面的代码是函数体
*/
int main()
{
// printf()是stdio.h中系统提供的函数，表示在标准输出设备上打印字符串
// ; 表示一条语句的结束
// \n 是一个转义字符，表示换行
printf("hello world!\n"); // 在控制台中打印hello world
// return如果出现在其它函数中，表示程序结束，
// 如果出现在main函数中，表示程序结束
// 函数返回的数据0要和函数返回值类型对应
return 0;
}
在 C语言 中，多行注释不能嵌套使用；
注释的内容不会参与编译和运行，仅仅是对代码的解释说明；
二、关键字
关键字 就是被 C语言 赋予了特定含义的英文单词，在 C语言 中所有关键字都是全部小写的；
【1】、数据类型关键字
| 关键字 | 含义 |
|---|---|
| char | 声明字符型变量或者函数，属于整型数据的一种 |
| short | 修饰 int，声明短整型变量或函数，可省略被修饰的int |
| int | 声明整型变量或者函数，通常为编译器指定的机器字长 |
| long | 修饰 int，声明长整型变量或者函数，可省略被修饰的int |
| float | 声明单精度浮点型变量或函数 |
| double | 声明双精度浮点型变量或函数 |
| unsigned | 修饰整型数据，声明无符号类型变量或函数 |
| signed | 修饰整型变量，声明有符号类型变量或函数 |
| struct | 声明结构体变量或函数 |
| union | 声明共用体数据类型 |
| enum | 声明枚举类型 |
| void | 声明函数无返回值或无参数，声明无类型指针 |
【2】、控制语句关键字
| 关键字 | 含义 |
|---|---|
| if | 条件语句 |
| else | 条件语句否定分支（与 if 连用） |
| switch | 用于开关语句 |
| case | 开关语句分支 |
| default | 开关语句中的 “默认”分支，可选结构 |
| for | for 循环语句 |
| do | do...while 循环结构的循环体 |
| while | do...while 或 while 循环结构的循环条件 |
| break | 跳出当前循环或 switch 分支结构 |
| continue | 结束当前循环，开始下一轮循环 |
| goto | 无条件跳转语句 |
| return | 子程序/函数体返回语句（可以带参数，也可以不带参数） |
【3】、存储类关键字
| 关键字 | 含义 |
|---|---|
| auto | 声明自动变量，有编译器自动分配和释放（通常在栈上分配） |
| extern | 指定变量为外部变量，即在其它文件中声明 |
| register | 声明寄存器变量，建议编译器将变量存储到寄存器中 |
| static | 声明静态变量，分配在静态变量区，修饰函数时用于限定作用域 |
| const | 声明只读变量 |
【4】、其它关键字
| 关键字 | 含义 |
|---|---|
| sizeof | 计算数据类型长度 |
| typeof | 用以给数据类型取别名 |
| volatile | 说明变量在程序执行中可被隐含地改变 |
三、变量
3.1、变量的概念
变量就是在程序的执行过程中，其值可能发生改变的量（数据）；变量是内存中的一个存储区域（不同的数据类型，占用的空间大小也不一样），该区域的数据可以在同一类型范围内不断的改变，变量是程序中最基本的存储单元，包含 变量类型、变量名 和 存储的值。
3.2、变量的作用
变量的作用就是在内存中保存数据；我们可以使用变量名来访问这块区域的数据；
3.3、变量的定义
变量的定义：
数据类型 变量名;
int a;
3.4、变量的赋值
变量的赋值：
变量名 = 变量值;
a = 10;
变量可以在声明的同时赋值：
数据类型 变量名 = 变量值;
int a = 10;
- 数据类型：为空间中存储的数据，加入类型（限制）
- 变量名：为空间起的名字
- 数据值：存在空间里面的数值
#include <stdio.h>
int main()
{
// 定义变量
// 数据类型 变量名 = 数据值;
int a = 10,b = 20;
// 格式化输出，%d输出整型数据
printf("a = %d,b = %d\n",a,b);
return 0;
}
在 C语言 中每个变量必须 先声明，再初始化，后使用；
在同一个作用域中，变量名不能重复声明，但变量可以重新赋值；
一行上可以同时声明多个变量，使用“,”隔开；
4.5、变量的作用域和生命周期
所谓的变量的作用域就是变量的有效范围；变量的作用域为其定义所在的一对{}内，即出了大括号就不认识了；变量的生命周期指的是变量的创建到变量销毁之间的一个时间段。
局部变量的作用域：是变量所在的局部范围；
全局变量的作用域：是整个工程；
局部变量的生命周期：进入局部范围生命开始，出局部范围生命结束；
全局变量的生命周期：整个程序的生命周期；
4.6、变量的分类
【1】、按照数据类型分类
【2】、按照变量定义位置分类
在一个函数内部定义的变量，只在本函数范围内有效。在复合语句内定义的变量，只在本复合语句范围内有效；
函数的形参也属于局部变量，作用范围仅限于函数内部的所有语句块；
如果一个变量在所有函数外部定义，那么这个变量就是全局变量。全局变量是可以在程序中的任何位置进行访问的变量；
当局部变量和全局变量名字冲突的情况下，局部优先。
四、常量
常量 指的是在计算机程序运行时，不会被程序修改的量；在 C语言 中，常量主要分为以下几种类型：
- 字面常量
- 整型常量，可以是十进制、八进制或十六进制的常量。前缀指定基数：0x 或 0X 表示十六进制，0 表示八进制，不带前缀默认表示 十进制。整型常量也可以带一个后缀，后缀是 U 和 L 的组合，U 表示无符号整数，L 表示长整数，后缀可以大写也可以小写，U 和 L 的顺序任意。例如：100，200，-100，0，037，0x5A
- 浮点型常量，由整数部分、小数点、小数部分 和 指数部分 组成，可以使用小数形式或者指数形式来表示浮点型常量。例如：3.14，0.125，-3.14，314159E-5
- 字符型常量，是括在单引号中的单个字符。字符常量可以是一个普通的字符，也可以是一个转义字符。例如：'a'，'A'，'\n'
- 字符串常量，是括在双引号中的字符序列。在字符串常量中，我们可以使用 '\' 实现换行。 例如："hello"，"a"，"123"
const修饰的常变量#define定义的标识符常量- 枚举常量
#include <stdio.h>
int main()
{
// 整型字面量
int i1 = 100;
int i2 = -100;
int i3 = 037;
int i4 = 0x5A;
// 浮点型字面量
double d1 = 3.14;
double d2 = -3.14;
double d3 = 314159E-5;
float f1 = 3.14;
// 字符字面量
char c1 = 'a';
char c2 = 'A';
char c3 = '\n';
// 字符串字面量
char str1[] = "hello";
char str2[] = "a";
char str3[] = "123";
char str4[] = "hello world";
char str5[] = "hello \
world";
printf("%d\n",i1);
printf("%d\n",i2);
printf("%d\n",i3);
printf("%d\n",i4);
printf("\n");
printf("%lf\n",d1);
printf("%lf\n",d2);
printf("%lf\n",d3);
printf("%f\n",f1);
printf("\n");
printf("%c\n",c1);
printf("%c\n",c2);
printf("%c\n",c3);
printf("\n");
printf("%s\n",str1);
printf("%s\n",str2);
printf("%s\n",str3);
printf("%s\n",str4);
printf("%s\n",str5);
return 0;
}
#include <stdio.h>
// 宏定义常量
#define PI 3.14
int main()
{
// 使用const关键字定义常量
const double pi = 3.14;
// 常量赋值之后，不能更改
//pi = 3.1415926;
// 格式化输出，%lf输出双精度浮点型数据，默认保留6位小数
printf("pi = %lf\n",pi);
// .2f，保留两位小数
printf("pi = %.2lf\n",pi);
return 0;
}
const 和 define 定义常量的区别：
- const 定义的常量带类型，define 不带类型；
- const 是在编译、运行的时候起作用，而 define 是在编译的预处理阶段起作用的；
- define 只是简单的替换，没有类型检查；
- const 常量可以进行调试的，而 define 是不能进行调试的，主要是因为在预编译阶段 define 定义的常量就已经替换掉了，调试的时候没有了；
- const 不能重定义，不可以定义两个一样的，而 define 通过 undef 可以取消某个符号的定义，在重新定义；
- define 可以配合 #indef、#ifndef、#endif 来使用，可以让代码更加灵活；
#include <stdio.h>
#define A 1
#define B A+3
#define C A/B*3
int main()
{
// C其实是A/A+3*3
printf("%d\n",C);
return 0;
}
五、数据类型
C语言的数据类型分为 基本数据类型、构造数据类型、指针类型 和 空类型。
5.1、基本数据类型
在 C语言 中，一共有 7 种基本类型（primitive type），其中有 4 种整型，2 种浮点型 和 1 种字符型 char。在 C语言 中，没有字符串类型，而是使用字符数组来表示字符串。在不同的系统下，部分数据类型占用的字节大小也可能不同。
5.1.1、整型类型
整形用于表示没有小数部分的数值，允许是负数，C语言 中提供了以下几个类型：short、int、long、long long；C语言 的整型常量默认是 int 型，如果要显示地声明 long 型常量需后加 'l' 或 'L' ，声明 long long 型常量需后加 'll' 或 'LL'。
| 数据类型 | 占用空间 |
|---|---|
| [signed] short [int]（有符号短整型） | 2 字节，取值范围：-32768~32767 |
| unsigned short [int]（无符号短整型） | 2字节，取值范围：0~65535 |
| [signed] int（有符号整型） | 4 字节，取值范围：-2147483648~-2147483647 |
| unsigned int（无符号整型） | 4 字节，取值范围：0~4294967295 |
| [signed] long [int]（长整型） | Window 为 4字节，Linux 为 4字节（32位），8字节（64位） |
| unsigned long [int]（无符号长整型） | Window 为 4字节，Linux 为 4字节（32位），8字节（64位） |
| [signed] long long [int]（长长整型） | 8 字节 |
| unsigned long long [int]（无符号长长整型） | 8 字节 |
#include <stdio.h>
int main()
{
short int s = 10; // int可以省略
int i = 10; // int可以省略
long int l = 10; // int可以省略
long long int ll = 10; // int可以省略
signed int a = -10; // 定义一个有符号整数，signed可以省略
unsigned int b = 10; // 定义一个无符号整数
printf("%hd\n",s); // 输出短整型数据
printf("%d\n",i); // 输出一个整型数据
printf("%ld\n",l); // 输出一个长整型数据
printf("%lld\n",ll); // 输出一个长长整型的数据
printf("%d\n",a); // 输出一个有符号的10进制整型
printf("%u\n",b); // 输出一个10进制的无符号数
return 0;
}
我们可以使用 sizeof 关键字来计算数据类型在内存中占用的字节（byte）大小，它的语法格式如下：sizeof(数据类型) 或 sizeof(变量名)。
#include <stdio.h>
int main()
{
// sizeof计算数据类型在内存中占用的字节大小
// 语法格式：sizeof(数据类型) 或 sizeof(变量名)
// %u 输出一个无符号整型数据
printf("短整型：%u\n",sizeof(short));
printf("整型：%u\n",sizeof(int));
printf("长整型：%u\n",sizeof(long));
printf("长长整型：%u\n",sizeof(long long));
return 0;
}
整型的数据在内存中占的字节数与所选择的操作系统有关。虽然 C语言 标准中没有明确规定整型数据的长度，但 long 类型整数的长度不能短于 int 类型，short 类型整数的长度不能长于 int 类型，即
short <= int <= long < long long。当一个小的数据类型赋值给一个大的数据类型，不会出错，因为编译器会自动转换。但当一个大的数据类型赋值给一个小的数据类型，那么就可能丢失高位。
5.1.2、浮点类型
浮点类型用于表示小数部分的数值。C语言 中浮点类型常量默认是 double 类型，也可以在浮点数值后面添加后缀 'd' 或 'D' ；声明 float 类型的常量，需后加 'f' 或 'F'。double 型变量所表示的浮点数比 float 型变量更加精确。
浮点类型不能准确的表达一个浮点数，可能会有舍入误差。
| 数据类型 | 占用空间 |
|---|---|
| float（单精度类型） | 4 个字节，取值范围：1.2E-38 到 3.4E+38，6 位有效位 |
| double（双精度类型） | 8 个字节，取值范围：2.3E-308 到 1.7E+308，15 位有效位 |
| long double（长双精度类型） | 16 字节，取值范围：3.4E-4932 到 1.1E+4932，19 位有效位 |
#include <stdio.h>
int main()
{
float f = 3.14f;
double d = 3.14;
long double ld = 3.14;
printf("%f\n",f);
printf("%lf\n",d);
printf("%lf\n",ld);
printf("float：%u\n",sizeof(float));
printf("double：%u\n",sizeof(double));
printf("long double：%u\n",sizeof(ld));
return 0;
}
float 表示的数值的范围比 long 还大；
浮点型数据存储在内存中的格式分为三个部分：符号位、指数位、小数位；
5.1.3、字符类型
字符型变量用于存储一个单一字符，在 C语言 中用 char 表示，其中每个字符变量都会占用 1 个字节。char类型的字面量值要用一对单引号（' '）括起来，内部只能写一个字符。
字符型变量实际上并不是把该字符本身放到变量的存储单元中去，而是将 该字符对应的 ASCII 编码放到变量的存储单元中。char 的本质就是一个 1字节 大小的整型，取值范围为：-128~127；我们可以直接给 char 类型的变量赋值一个整数，在输出时，可以按照 ASCII码 输出。char 类型的变量还可以进行运算，相当于一个整数。
| 数据类型 | 占用空间 |
|---|---|
| [signed] char | 1 字节，取值范围：-128~127 |
| unsigned char | 1 字节，取值范围：0~255 |
#include <stdio.h>
int main()
{
// 定义字符变量
char ch = 'a';
unsigned char uch = 97;
// 格式化输出，%c输出字符型数据
printf("字符：%c\n",ch);
// 打印字母对应的ASCII码
printf("ANSCII：%d\n",ch);
printf("%c\n",uch);
printf("%d\n",uch);
printf("字符型：%u\n",sizeof(ch));
return 0;
}
在 C语言 中，有一些特定的字符，当它们前面有反斜杠时，它们就具有特殊的含义，这种字符称为 转义字符。
| 转义字符 | 含义 | ASCII码值（十进制） |
|---|---|---|
| \a | 警报 | 007 |
| \b | 退格，将当前位置移到前一列 | 008 |
| \f | 换页，当当前位置移到下页开头 | 012 |
| \n | 换行，将当前位置移到下一行开头 | 010 |
| \r | 回车，将当前位置移到本行开头 | 013 |
| \t | 水平制表符，跳到下一个 tab 位置 | 009 |
| \v | 垂直制表符 | 011 |
| \\ | 代表一个反斜线字符，\ | 092 |
| \' | 代表一个单引号字符，' | 039 |
| \" | 代表一个双引号字符，" | 034 |
| \? | 代表一个问号，? | 063 |
| \0 | 数字 0 | 000 |
| \ddd | ddd 表示 1~3 个八进制的数字 | 3位 8进制 |
| \xdd | dd 表示 2 个十六进制数字 | 3位 16进制 |
#include <stdio.h>
int main()
{
printf("hello world!\n");
printf("\thello\n");
printf("鲁迅说：\"这句话我从未说过\"\n");
printf("子曰：\'学而时习之，不亦说乎！\'\n");
printf("御坂美琴 夏娜\r木之本樱\n");
printf("\\\n");
printf("%%\n");
return 0;
}
5.2、基本数据类型转换
无论是 自动类型转换 还是 强制类型转换，都只是为了本次运算的需要，而 对变量的数据的长度进行临时性转换，而不改变数据说明时对该变量定义的类型。
5.2.1、自动类型转换
当容量小的数据类型的变量与容量大的数据类型的变量做运算时，结果自动提升为容量大的数据类型（此时的容量大小指的是，表示数的范围的大和小）。
#include <stdio.h>
int main()
{
char ch = 'a';
short s = ch;
printf("%c\n",ch);
printf("%hd\n",s);
return 0;
}
有多种类型的数据混合运算时，系统首先会自动将所有数据转换成精度最大的那种数据类型，然后再进行计算；
若两种类型的字节数不同，转换成字节数大的类型，若两种类型的字节数相同，且一种有符号，一种无符号，则转成成无符号类型；
在赋值运算中，赋值号两边量的数据类型不同时，赋值号右边量的类型将转换成左边量的类型，如果右边变量的数据类型长度比左边长时，将丢失一部分数据，这样会降低精度，丢失的部分按四舍五入向前舍入；
5.2.2、强制类型转换
强制类型转换就是自动类型提升运算的逆运算；我们需要 使用强转符：() 来强制转换；它的格式如下：目标数据类型 变量名 = (目标数据类型) 被强转的数据;
#include <stdio.h>
int main()
{
int i1 = 200;
char ch = (char)i1;
float f = 3.14f;
double d = (int)f;
printf("%d\n",ch);
printf("%lf\n",d);
return 0;
}
强制类型转换可能会损失精度，导致数据错误；
强制类型转换操作不会改变操作数本身；
六、标识符
6.1、什么是标识符
标识符（identifier）是指用来标识某个实体的一个符号，在不同的应用环境下有不同的含义。在计算机编程语言中，标识符是用户编程时使用的名字，用来给变量、常量、函数等命名，以建立起名字与使用之间的关系。标识符通常由字母和数字以及其它字符构成。
在编程语言中，标识符就是程序员自己规定的代表一定含义的单词，比如变量名、常量名、函数名等。
6.2、标识符的命名规则
- 标识符只能由数字、字母（26个英文字母大小写）、下划线（_）组成；
- 标识符不能以数字开头；
- 不可以使用关键字作为标识符，但可以包含关键字；
- 标识符严格区分大小写；
- 见名知意；
#include <stdio.h>
int main()
{
int useId = 1;
int age = 10;
int minNum = 3;
int max_num = 30;
return 0;
}
七、数据输入输出
在 C语言 中，所有的数据输入输出都是由库函数完成的。在 C语言 中，使用标准输入输出库函数需要使用“stdio.h” 头文件，因此在程序开头应该有 #include "stdio.h" 语句。
7.1、格式输出函数
在 C语言 中，可以使用 printf() 函数输出指定类型的数据，printf() 函数的作用是向终端（输出设备）输出若干任意类型的数据，其语法格式如下：
printf(格式控制,输出列表);
【1】、格式控制
格式控制 是用双引号括起来的字符串，也可以称为 转换控制字符串，其中包括 格式字符 和 普通字符 两种。
- 格式字符 用来进行格式说明，作用是将输出的数据转换为指定的格式输出。格式字符是以 "%" 字符开头的。
- 普通字符 是需要原样输出的字符，其中包括双引号内的逗号、空格和换行符。
【2】、输出列表
输出列表 中列出的是要进行输出的一些数据，可以是变量或表达式。
由于 printf() 是函数，”格式控制“ 和 ”输出列表“ 这两个位置都是函数的参数，因此 printf() 函数的一般形式也可以表示为：
printf(参数1,参数2,参数3);
函数中的每一个参数按照给定的格式和顺序依次输出。
printf() 函数的 格式字符：
| 打印格式 | 对应数据类型 | 含义 |
|---|---|---|
| %d | int | 有符号的十进制整数 |
| %hd | short | 短整型 |
| %hu | unsigned short | 无符号短整型 |
| %o | unsigned int | 无符号 8进制 整数 |
| %u | unsigned int | 无符号 10进制 整数 |
| %x，%X | unsigned int | 无符号 16进制 整数，x是指字母以小写输出，X是指字母以大写输出 |
| %f | float | 单精度浮点数 |
| %lf | double | 双精度浮点数 |
| %e，%E | double | 科学计数法表示的数，此处的”e“的大小写代表在输出时用的”e“的大小写 |
| %c | char | 字符型，可以把输入的数字按照 ASCII码 转换为对应的字符 |
| %s | char * | 字符串，输出字符串中的字符直至字符串中的空制符（'\0'） |
| %p | void * | 以 16进制 形式输出指针 |
| %% | % | 输出一个百分号 |
printf() 函数的 附加格式：
| 字符 | 含义 |
|---|---|
| l（字母l） | 附加在 d，u，x，o 前面，表示长整型 |
| - | 左对齐 |
| m（代表一个整数） | 数据最小宽度 |
| 0（数字0） | 将输出的前面补上 0 直到沾满指定列宽为止，不可以搭配使用 |
| m.n（代表一个整数） | m 指 域宽，即对应的输出项在输出设备上所占的字符数； n 指 精度，用于说明输出的浮点数的小数位数； 对数值型的来说，未指定 n 时，隐含的精度为 n=6； |
#include <stdio.h>
int main()
{
signed int a = -10; // 定义一个有符号整数，signed可以省略
unsigned int b = 10; // 定义一个无符号整数
int c = 10; // 定义一个10进制数
int d = 012; // 定义一个8进制数，以0开头（0-7）
int e = 0xa; // 定义一个16进制数，以0x开头 （1-9，a-f）
printf("%d\n",a); // 输出一个有符号的10进制整型
printf("%u\n",b); // 输出一个10进制的无符号数
printf("%o\n",d); // 输出一个8进制的整型
printf("%x\n",c); // 输出一个16进制的整型，字母以小写输出
printf("%X\n",c); // 输出一个16进制的整型，字母以大写输出
return 0;
}
7.2、格式化输入
在 C语言 中，格式输入使用 scanf() 函数，scanf() 函数通过 % 转义的方式可以获取用户通过标准输入设备输入的数据。在函数的功能是指定固定的格式，并且按照指定的格式接收用户在键盘上输入的数据，最后将输出在指定变量中。scanf() 函数的一般格式如下：
scanf(格式控制,地址列表);
通过 scanf() 函数的一般格式可以看出，参数位置的格式控制与 printf() 函数相同。而在地址列表中，此处应该给出用来接收数据变量的地址。
在输入多个字符时，若格式控制串中没有非格式字符作为输入数据之间的间隔，则可以用 空格、TAB、回车 作为间隔。C编译器 遇到 空格、TAB、回车 或 非法数据时，即认为该数据结束；
#include <stdio.h>
int main()
{
int a,b;
printf("请输入两个数字，以空格分隔：");
// &运算符，表示取地址运算符，多个占位符默认是以空格分隔，
scanf("%d%d",&a,&b);
printf("你输入的两个数字是：%d %d\n",a,b);
printf("请在输入两个数字，以英文逗号分隔：");
scanf("%d,%d",&a,&b);
printf("你输入的两个数字是：%d %d\n",a,b);
printf("请输入一个3位整数：");
scanf("%3d",&a);
return 0;
}
7.3、字符数据输出
字符数据输出就是将字符显示出来。 在 C语言 中，使用 putchar() 函数输出字符数据，它的作用是向显示设备输出一个字符。putchar() 函数可以输出字符、字符变量、数字（0~127）、转义字符。其语法格式如下：
int pubchar(int ch);
其中的 参数 ch 是要进行输出的字符，可以是 字符型变量 或 整型变量，也可以是常量。
#include <stdio.h>
int main()
{
char ch = 'a';
putchar(a);
putchar('\t');
putchar('A');
putchar('\n');
putchar(97);
return 0;
}
7.4、字符数据输入
在 C语言 中，可以使用 getchar() 函数是从标准输入设备读取一个字符，它的语法格式如下：
int getchar();
#include <stdio.h>
int main()
{
char ch;
printf("请输入一个字符：");
ch = getchar();
printf("你输入的字符是：%c",ch);
return 0;
}
7.5、字符串输出函数
字符串输出就是将字符串输出到控制台上。在 C语言 中，字符串输入使用的是 puts() 函数，它的作用是输出字符串并显示在屏幕上。其语法格式如下：
int puts(char *str);
其中，形式参数 str 是字符指针类型，可以用来接收要输出的字符串。puts() 函数会在字符串中判断 '\0' 结束符。遇到结束符时，后面的字符不再输出，并且自动换行。
#include <stdio.h>
int main()
{
puts("hello world!");
return 0;
}
7.6、字符串输入函数
在 C语言 中，字符串输入使用的是 gets() 函数，它的作用是将读取的字符串保存在形式参数中，读取过程直到出现新的一行为止。其中新的一行的换行符将会自动转换为字符串中的空终止符 '\0'。它的语法格式如下：
char *gets(char *str);
其中 str 字符指针变量为形式参数，从终端读取到的字符串将会保存在这个变量中。
#include <stdio.h>
int main()
{
char str[20];
puts("请输入一个字符串：");
gets(str);
puts("你输入的字符串是：");
puts(str);
return 0;
}
标签：02,字符,变量,int,基础知识,整型,printf,C语言,函数 From： https://www.cnblogs.com/kurome/p/17122445.htmlputchar() 函数是字符输出函数，它只能从终端 输入一个字符；
puts() 函数是字符串输入函数，它向终端输出 字符串并换行；
printf() 函数是格式化输出函数，它向终端 按格式输出；
getchar() 函数是字符输入函数，它只能从终端 读入一个字符；
gets() 函数是字符串输入函数，作用是 将读取的字符串保存在形式参数变量中，读取过程直到出现新的一行为止；
scanf() 函数是格式输入函数，功能是指定固定的格式，并且 按照指定的格式接收用户在键盘上输入的数据，最后将数据存储在指定的变量中；