02. C语言基础知识

一、注释

  注释 就是对代码进行解释说明的文字，注释的内容不会参与编译和运行，仅仅是对代码的解释说明。在 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语言 中每个变量必须 先声明，再初始化，后使用；

在同一个作用域中，变量名不能重复声明，但变量可以重新赋值；

一行上可以同时声明多个变量，使用“,”隔开；

3.5、变量的作用域和生命周期

  所谓的变量的作用域就是变量的有效范围；变量的作用域为其定义所在的一对{}内，即出了大括号就不认识了；变量的生命周期指的是变量的创建到变量销毁之间的一个时间段。

局部变量的作用域：是变量所在的局部范围；

全局变量的作用域：是整个工程；

局部变量的生命周期：进入局部范围生命开始，出局部范围生命结束；

全局变量的生命周期：整个程序的生命周期；

3.6、变量的分类

3.6.1、按数据类型分类

3.6.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 定义常量的区别：

1. const 定义的常量带类型，define 不带类型；
2. const 是在编译、运行的时候起作用，而 define 是在编译的预处理阶段起作用的；
3. define 只是简单的替换，没有类型检查；
4. const 常量可以进行调试的，而 define 是不能进行调试的，主要是因为在预编译阶段 define 定义的常量就已经替换掉了，调试的时候没有了；
5. const 不能重定义，不可以定义两个一样的，而 define 通过 undef 可以取消某个符号的定义，在重新定义；
6. 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;
}

putchar() 函数是字符输出函数，它只能从终端 输入一个字符；

puts() 函数是字符串输入函数，它向终端输出 字符串并换行；

printf() 函数是格式化输出函数，它向终端 按格式输出；

getchar() 函数是字符输入函数，它只能从终端 读入一个字符；

gets() 函数是字符串输入函数，作用是 将读取的字符串保存在形式参数变量中，读取过程直到出现新的一行为止；

scanf() 函数是格式输入函数，功能是指定固定的格式，并且 按照指定的格式接收用户在键盘上输入的数据，最后将数据存储在指定的变量中；